# I Built an AI Assistant That Asks 3 AI Models Before Answering

Most AI chat applications rely on a single model.

I wanted to experiment with something different:

What if an AI assistant could ask multiple models the same question and then combine their responses into one answer?

That idea became AVS — AI Vision System, a full-stack, multi-model AI chat application that I built using ASP.NET Core, C#, JavaScript, Firebase, Ollama, Groq, Gemini, and Hugging Face.

What is AVS?

AVS is a self-hosted AI chat platform with three different modes:

• VS-1 Basic — local AI through Ollama
• VS-G1 Image — image generation using FLUX.1-schnell
• VS-2 Pro — queries three AI systems and synthesizes their responses

The interesting part is VS-2 Pro.

Instead of:

User
  ↓
AI Model
  ↓
Answer

AVS does this:

                    User
                      │
                      ▼
                   AVS API
                      │
          ┌───────────┼───────────┐
          │           │           │
          ▼           ▼           ▼
        Groq       Gemini      Ollama
          │           │           │
          └───────────┼───────────┘
                      │
                      ▼
                  Synthesis
                      │
                      ▼
                 Final answer

The responses from Groq, Gemini, and Ollama are collected and synthesized using Gemini.

The goal isn't to claim that three models automatically produce a "perfect" answer. The goal is to experiment with multi-model reasoning and orchestration.

Why use multiple models?

Different models can behave differently when given the same prompt.

One might produce a concise answer.

Another might provide more explanation.

Another might approach the problem differently.

That creates an interesting engineering problem:

How can an application coordinate several AI systems and turn their outputs into something useful?

That became one of the central ideas behind AVS.

The three modes

VS-1 Basic

The Basic mode uses Ollama running locally.

This gives AVS a local AI option without requiring every request to go through a cloud model.

AVS
 │
 ▼
Ollama
 │
 ▼
llama3.2

This was also an opportunity to experiment with locally hosted AI rather than treating cloud APIs as the only option.

VS-G1 Image

The image mode uses the Hugging Face Inference API with FLUX.1-schnell.

User prompt
     │
     ▼
AVS
     │
     ▼
Hugging Face
     │
     ▼
FLUX.1-schnell
     │
     ▼
Generated image

VS-2 Pro

This is the most interesting mode.

AVS sends the user's request to:

• Groq using Llama 3.3 70B
• Google Gemini 2.5 Flash
• Ollama

The responses are then combined and passed through a synthesis stage.

                 User
                   │
                   ▼
              VS-2 Pro
                   │
       ┌───────────┼───────────┐
       ▼           ▼           ▼
     Groq        Gemini      Ollama
       │           │           │
       └───────────┼───────────┘
                   ▼
               Synthesis
                   │
                   ▼
              Final answer

This turned the application from a simple chatbot into an experiment in AI orchestration.

Beyond the AI

AVS isn't only an AI API wrapper.

I also wanted it to behave like a real application.

Authentication

Users can create accounts using:

• Email and password
• Google authentication

Persistent conversations

Chat sessions are stored in Firebase Firestore.

That means conversations aren't limited to one browser session.

Users can sign in from another device and retrieve their previous conversations.

File uploads

AVS supports attaching:

• Images
• PDFs
• Text files
• Code files

The contents can then be incorporated into the AI prompt.

Session memory

The conversation context is sent along with subsequent messages, allowing the assistant to maintain the context of a session.

User interface

I also built a custom interface rather than relying on an existing chat UI.

It includes:

• Dark theme
• Animated thinking indicators
• Progress indicators
• Suggestion chips
• Collapsible model responses
• Individual response visibility in Pro mode

The UI is intentionally designed around the idea that the user shouldn't have to understand the underlying multi-model architecture to use AVS.

Technology stack

What I learned

Building AVS taught me that connecting APIs is the easy part.

The harder questions are architectural.

How should different models communicate?

What happens when one provider fails?

How should responses be handled?

How should user data be stored?

How do you maintain conversation context?

How do you expose the complexity of the system without making the interface complicated?

Those questions were more interesting to me than simply getting a chatbot to respond.

What's next?

AVS is still a project I want to improve.

Some of the areas I want to explore further include better model routing, improved reliability, more tools, stronger security, and better ways of evaluating whether multi-model responses are actually better than individual model responses.

For now, AVS is my experiment in building an AI system rather than simply using one.

And this is only the beginning.

Repository: AVS-AI-Assistant

If you're interested in the architecture or implementation, the source code is available on my GitHub.