The problem with a single agent

Give one LLM too many tools and responsibilities, and performance degrades. The model has to reason about all possible tools at once. Tool selection gets worse. Everything competes for space in one context window. More tokens means slower responses, higher cost, and often worse accuracy.

This is especially true in healthcare, where tasks span multiple specialized domains. Clinical reasoning requires different context than billing logic. Scheduling optimization requires different tools than guideline lookup. Each domain has its own knowledge base and data sources.

A single agent trying to do everything ends up doing nothing particularly well.

How multi-agent systems work

Multi-agent systems break the problem into parts. Instead of one model juggling everything, you have specialized agents (experts) handling specific domains, coordinated by an orchestrator.

The Orchestrator

• Receives the user's request
• Reasons at a high level about what needs to happen
• Decides which experts to call (and can call multiple in parallel)
• Synthesizes results into a final response

The Experts

• Specialized sub-agents with narrow scope
• Each has its own system prompt and limited tool set
• Only sees what's relevant to its task
• Returns results to the orchestrator

A reference expert does not have billing tools cluttering its context. A coding expert does not have scheduling tools. Each expert operates in a focused environment, which improves tool selection and response quality.

A concrete example

Request: "What's the appropriate metformin dose for this patient given their kidney function?"

Single-agent approach: One LLM sequentially calculates renal function, then looks up dosing guidelines, then checks for interactions with current medications. Each step adds to the context window. The agent has to manage clinical calculators, drug databases, and interaction checkers all at once.

Multi-agent approach:

1. Orchestrator receives request
2. Orchestrator calls experts in parallel:
   • Medical Calculator expert calculates eGFR from the patient's labs
   • DrugBank expert pulls metformin renal dosing thresholds
   • Posos expert checks interactions with the patient's current medication list
3. Results return to orchestrator
4. Orchestrator synthesizes a dosing recommendation with relevant safety considerations

Each expert queries only its domain. The Medical Calculator handles the math. DrugBank handles pharmacology. Posos handles interaction checking. No single agent needs to juggle all three knowledge bases.

Why this architecture is needed for healthcare

Healthcare tasks often span domains: clinical data, billing codes, guidelines, scheduling, prior authorization. The right approach depends on the specific request and what data exists.

This mirrors how healthcare actually operates. A physician does not also handle billing and prior authorization and appointment scheduling. Different people with different expertise handle different parts of the process. Multi-agent systems follow the same principle.

What you gain:

• Better accuracy. Specialized agents with focused context make fewer mistakes than a generalist trying to do everything.
• Cleaner architecture. Each agent has a clear responsibility. Easier to build, test, and maintain.
• Flexibility. Need to add a new capability? Add a new agent. Need to change how coding works? Update that agent without touching the rest.
• Faster execution. Agents can work in parallel. A discharge readiness check can query vitals, labs, medications, and follow-up appointments simultaneously rather than sequentially.

Build on Corti: Multi-agent architecture as a service

When you configure an agent on Corti, you're not getting a single LLM with a pile of tools. You're getting an orchestrator coordinating specialized experts, with the infrastructure to make that architecture work.You configure the orchestrator's behavior: its system prompt, which experts it can call, what data it can access. Corti handles the rest: multi-agent coordination, context management, parallel execution, memory, and failure handling.

The alternative is building your own orchestration layer, managing context windows manually, implementing parallel execution, handling retries and failures, and optimizing prompts across multiple agents. That's months of infrastructure work before you ship anything.

Corti abstracts that away. The artchitecture is already built. You configure to your specific use case on top of it.

‍