One Giant LLM Won't Run Your Business. A Team of Narrow Agents Might.

There's a fantasy in enterprise AI: a single, all-knowing model that does everything — underwriting, claims, servicing, support — one prompt to rule them all. In practice, the architecture that actually ships and survives looks less like a monolith and more like an org chart: narrow agents with defined jobs, explicit handoffs, and a human on the consequential calls. This isn't a compromise. In a regulated, high-accountability domain, it's the correct design.

Why the monolith fails

• You can't inspect it. When one giant model makes every decision, "why did it do that?" has no clean answer. In insurance (and finance, and healthcare) you must be able to say which component did what and why. A monolith is an audit black hole.
• Blast radius. A prompt change to improve claims handling silently degrades underwriting, because it's all one tangled context. Narrow agents fail in isolation.
• Context dilution. Cramming every tool, policy, and instruction into one context window makes the model worse at all of it. Specialists with focused context and tools outperform a generalist juggling everything.
• No least privilege. The agent that answers FAQs should not have the tool that moves money. One monolith = one over-privileged blast radius.

The shape that works

Model it like a team:

        ┌─────────────┐
        │ Orchestrator│  routes by intent, holds no domain authority
        └──────┬──────┘
     ┌─────────┼──────────┬───────────────┐
     ▼         ▼          ▼               ▼
 [Intake]  [Underwrite] [Claims]     [Servicing]
  narrow    narrow, RAG  narrow,       narrow,
  extract   over guides  HIL-gated     read + safe writes
     │         │          │               │
     └─────────┴────► human-in-the-loop on consequential actions
                    └────► audit log: which agent, which inputs, which decision

Each agent:

• has a single job and only the tools that job needs (least privilege),
• hands off with structured context, not a blob of chat history,
• writes to an immutable audit trail — which agent, what inputs, what it decided.

The three non-negotiables the moment agents act

The instant an agent moves from assisting to orchestrating real actions, you need:

1. Human-in-the-loop gates on consequential steps (approve, pay, cancel).
2. An immutable audit trail for every decision and handoff.
3. Guardrails against hostile input (see: prompt injection) — because narrow agents that read untrusted data must not hold privileged tools.

It's not AGI — it's good system design

The winning pattern isn't a smarter model; it's a well-run department that happens to be software. Narrow, inspectable, least-privilege agents with clean handoffs beat one monolith you can't debug, can't audit, and can't safely give authority to. The interesting engineering is in the orchestration, handoffs, and guardrails — the substrate — not in the size of any single model.

Full write-up with the insurance framing:

One Giant AI Won't Run an Insurance Company. A Team of Agents Might. →

From IntelliBooks' series on the data foundation under insurance AI.

Monolith or multi-agent in your stack? Where did you draw the agent boundaries?