If you've spent any time building with LLMs, you've probably hit the wall: a single prompt only gets you so far. Stuff too much into one prompt and the model loses the plot. Try to do too many things at once and you get inconsistent output.

The answer most teams converge on is multi-agent architectures — multiple specialized agents, each with a focused role, coordinated by an orchestrator. This post covers when and why to reach for multi-agent in .NET, what patterns work, and how to build them without losing your mind.

Why multi-agent?
Single-agent systems work great for narrow tasks: summarize this, translate that, classify the other. But when the task has multiple steps with different cognitive loads, single-agent breaks down.

Consider: "Research recent advances in retrieval-augmented generation, write a 500-word summary, and check it for factual accuracy." That's three jobs:

Research — needs broad context, can use tools, ok to be slow
Writing — needs focused context, ok to be fast, no tools needed
Fact-checking — needs verifying mindset, can use tools, narrow context
Cram all three into one prompt and you get a mediocre version of each. Split them into three agents and each one does its job well.

That's the multi-agent pitch in one sentence: specialization beats generalization, even at the prompt level.

When NOT to use multi-agent
Before getting excited, the honest answer: most production AI features should be single-agent. Multi-agent adds:

Latency — each agent is an LLM call. Three agents means 3x the wall-clock time.
Cost — same math, 3x the tokens.
Failure modes — any agent in the chain can fail or hallucinate, and downstream agents have to handle it.
Debugging complexity — when something goes wrong, which agent caused it?
If you can solve your problem with one well-crafted prompt and a structured output, do that. Multi-agent is for problems you genuinely can't fit into one head.

The patterns
There are five practical patterns. Each maps to a different problem shape.

1. Sequential The simplest pattern. Output of agent A → input of agent B → input of agent C. Use when steps are linear and each depends on the previous.

using LogicGrid.Core.Admins;

var admin = new SequentialAdmin<string, string>(
    name: "Pipeline",
    llmClient: llm,
    agents: new IAgent[] { researcher, writer, editor });

var result = await admin.RunAsync("Topic: Reciprocal Rank Fusion");

Best for: ETL-like flows, structured pipelines, document transformation.

1. Group chat Multiple agents share a conversation. An admin (often an LLM) decides who speaks next based on what the agents have said so far.

var admin = new GroupChatAdmin<string, string>(
    name: "Editorial",
    llmClient: llm,
    agents: new IAgent[] { researcher, writer, critic },
    options: new AdminOptions { MaxLoops = 10 });

var article = await admin.RunAsync(
    "Explain hybrid search in 200 words.");

The admin LLM picks an agent, that agent contributes, then the admin picks again. The loop ends when the admin decides the task is done (often when a critic responds with "DONE").

Best for: open-ended creative tasks, debates, brainstorming, code review.

1. Graph (DAG) Each agent is a node. Edges describe data flow and conditionals. Branching, merging, and conditional routing are first-class.

using LogicGrid.Core.Graph;

var graph = AgentGraphBuilder
    .Start(classifier)
    .ThenIf(classifier, technicalAgent,
        condition: r => r.Contains("technical"))
    .ThenIf(classifier, friendlyAgent,
        condition: r => !r.Contains("technical"))
    .Then(technicalAgent, formatter)
    .Then(friendlyAgent, formatter)
    .Terminal(formatter)
    .Build();

var output = await graph.RunAsync("Why is my deploy failing?");

Best for: complex workflows, conditional logic, fan-in/fan-out patterns. The pattern most production systems eventually grow into.

1. Parallel + Map-Reduce Run multiple agents in parallel and aggregate results.

using LogicGrid.Core.Admins;

var admin = new ParallelAdmin<string, string>(
    name: "MultiAnalyst",
    llmClient: llm,
    agents: new IAgent[] { financialAnalyst, legalAnalyst, technicalAnalyst },
    aggregator: synthesizer);

var report = await admin.RunAsync(
    "Analyze this contract from three angles.");

Best for: tasks where multiple perspectives need to be combined. Document analysis, code review, due diligence.

1. Reflexion (self-critique) An actor generates output. A critic evaluates it. If the critic approves, the run ends. If not, the actor retries with feedback. Loops until approved or MaxIterations is reached.

var admin = new ReflexionAdmin<string, string>(
    name: "Refiner",
    llmClient: llm,
    actor: writer,
    critic: critic,
    options: new ReflexionOptions { MaxIterations = 3 });

var refined = await admin.RunAsync(
    "Write a marketing one-liner for our product.");

Best for: tasks where quality matters more than speed. Marketing copy, code generation, summarization of high-stakes content.

How to choose a pattern
Start by asking: what does my problem actually look like as a flowchart?

One step? You don't need multi-agent.
A linear sequence of steps? Sequential.
Steps that depend on what previous steps said, in a non-deterministic way? Group chat.
Steps with branches and merges? Graph.
Multiple independent perspectives that combine? Parallel + aggregate.
One step but you want it to be really, really good? Reflexion.
You can mix patterns. A graph node can be a group chat. A sequential pipeline can include a reflexion step at the end. The patterns compose.

Observability — the part nobody talks about
Multi-agent systems are notoriously hard to debug. When the user gets a bad answer, was it the researcher's fault? The writer's? The critic's? The admin?

The only way out is structured observability. Every agent step, every tool call, every retry, every LLM call should emit a structured event that you can query later.

LogicGrid does this by default:

var ctx = new AgentContext()
    .WithLogging()
    .WithTracing(out var trace);

await admin.RunAsync("Explain RRF in 200 words.");

// Inspect every step the admin and its agents took
foreach (var span in trace.Spans)
    Console.WriteLine($"{span.Name} — {span.Duration.TotalMilliseconds:F0}ms");

Every event includes: agent name, run ID, timing, token count, tool calls, errors. Pipe it to a structured log, OpenTelemetry collector, or your own analytics.

When a customer comes back with "the agent gave a bad answer," you can pull up the full trace and see exactly what happened.

Cost and latency
Three agents = three LLM calls = roughly 3x cost and 3x latency vs single agent. There are mitigations:

Mix model sizes. Use a small fast model for orchestration decisions and a large model only for the actual work.
Cache aggressively. Many multi-agent flows have agents that produce the same output for the same input. Cache at the agent boundary.
Run independent steps in parallel. Sequential is the worst case; parallel is free latency.
Run local for orchestration. Local LLMs (Ollama, vLLM) are essentially free per call. Use them for the cheap routing decisions and reserve hosted models for the heavy lifting.
LogicGrid makes all four easy because providers are interchangeable in one line.

A real example
Here's what a real production multi-agent system might look like — a code review bot:

var llm = LlmClientBase.Ollama("llama3.2");

IAgent securityReviewer = new Agent<string>(
    "Security", "Looks for security issues.",
    "Review the diff for security vulnerabilities. List concerns.", llm);

IAgent perfReviewer = new Agent<string>(
    "Performance", "Looks for performance issues.",
    "Review the diff for performance problems. List concerns.", llm);

IAgent styleReviewer = new Agent<string>(
    "Style", "Looks for style issues.",
    "Review the diff for style/readability. List concerns.", llm);

IAgent synthesizer = new Agent<string>(
    "Reviewer", "Synthesizes feedback.",
    "Combine the reviews into a single PR comment, prioritized.", llm);

var admin = new ParallelAdmin<string, string>(
    name: "CodeReviewBot",
    llmClient: llm,
    agents: new IAgent[] { securityReviewer, perfReviewer, styleReviewer },
    aggregator: synthesizer);

var review = await admin.RunAsync(diffText);
PostToGitHub(review);

Three independent reviewers run in parallel, then a synthesizer combines them into a single comment. Total wall-clock time is about the same as a single agent, but the output covers multiple dimensions.

Going further
Orchestration patterns — sequential, group chat, graph, parallel, map-reduce, reflexion
Observability— events, logging, tracing
Quickstart— build your first multi-agent system