Learning· 4 min read

How to Build a Multi-Agent System That Actually Finishes the Job

Standardized document part of Vault Migration Phase 1.

CyrilXBT (Summarized by Scribe)Undated

ATTRIBUTION. This is a summary of work published by CyrilXBT. It is not original Synergy research. Read the original: https://x.com/cyrilxbt/status/2068135133618540931

Content

🎯 The Core Thesis

Most multi-agent systems fail in a specific, highly predictable way. They start strong: a Researcher Agent pulls excellent, high-quality raw data, and a Writer Agent produces an impressive first draft. But as soon as the system enters iterative review, refinement, or editing loops, it collapses.

Without strict architectural constraints, multi-agent systems inevitably devolve into infinite loops, context pollution, or instruction drift, consuming massive token budgets while generating lower-quality outputs over time.

🚨 The 3 Predictable Failure Modes of Unconstrained Agents

1. The "Banter" Loop (Endless Revisions)

The Symptom: The Writer agent generates a draft. The Editor agent reviews it and lists five points of feedback. The Writer modifies the draft but fixes only four points. The Editor catches the remaining point and suggests more changes. The agents enter a ping-pong loop, endlessly editing minor phrasing and wasting thousands of dollars in token usage without completing the task.
The Cause: Absence of hard state limits or deterministic termination conditions in the orchestration framework.

2. Context Pollution & "Instruction Drift"

The Symptom: As agents pass the entire chat history back and forth containing successive drafts, criticism, and meta-commentary, the model's context window becomes crowded with conflicting feedback. The agents begin to lose track of the original, primary instructions. The output drifts from high-quality customized drafts into generic, repetitive AI banter.
The Cause: Forwarding raw, uncleansed, monolithic conversation threads between agent boundaries.

3. The "Monoculture" Blindspot

The Symptom: An Editor agent enthusiastically approves a draft written by a Writer agent despite it containing obvious hallucinations or analytical errors.
The Cause: Shared homogeneous models. When every agent is instantiated from the exact same base model (e.g., a standard model like GPT-4o), they share identical blind spots, structural biases, and statistical tendencies. Instead of critical verification, they default to "groupthink" and mutual reinforcement of errors.

🛠️ The Architectural Blueprints for Completion

To build a multi-agent system that consistently and reliably finishes the job, you must transition from loose "agent banter" to disciplined, state-machine-driven engineering.

1. Implement Strict State Machines & Directed Acyclic Graphs (DAGs)

Do not let agents decide when they are "done" through conversational agreement. Use frameworks like LangGraph or Google ADK to define a deterministic graph.
Set a hard physical cap on iterative loops (e.g., maximum of 3 revisions). Once the cap is hit, trigger a fallback to a "best-effort commit" or escalate to a human-in-the-loop gate.

2. Context Cleansing & Handoff Pruning

Never pass the raw conversation history of agent interactions to the next agent in the pipeline.
Implement a "Context Cleansing" filter. At each handoff, strip away the background chatter and pass only the current asset (e.g., the markdown document) and the structured checklist of remaining changes. Keep the inputs clean and lightweight to prevent instruction drift.

3. Build Cognitive Diversity (Heterogeneous Models)

Break the monoculture by assigning different base models based on role requirements:

The Planner/Editor (High-Cognition): Use a heavy reasoning model (such as Claude 3.5 Sonnet or OpenAI o1) to coordinate, review, and evaluate. The Researcher/Executor (High-Speed): Use smaller, faster, or specialized retrieval models (like Llama 3 8B or Gemini Flash) to run tools, fetch documents, and write drafts.

This introduces true cognitive friction, forcing the system to catch errors that a single-model setup would miss.

4. Schema-Driven Contracts (JSON Schema)

Do not allow agents to communicate in open-ended natural language.
Define rigid input/output boundaries using strict JSON schemas (or Model Context Protocol / MCP tool specs). If an agent fails to output a schema-conforming object, the runtime rejects it immediately rather than propagating messy formatting to downstream agents.

5. Human-in-the-Loop (HITL) Gates

Design specific "Pause & Wait" milestones within the execution graph. For high-risk decisions (e.g., API deployment, email sending, financial calculations, contract finalization), the state machine must halt and request human sign-off before proceeding.

💼 SME Consulting Application & Pitch Strategy

As an AI Strategist, you can leverage this framework to audit expensive vendor proposals and protect your SME clients:

The Pitch: "Most vendor pitches promise 'fully autonomous agents' that will run your business. What they don't tell you is that without rigid architectural constraints, these systems get stuck in endless token-burning loops and produce generic, drifted output. I design agentic blueprints built on state machines, heterogeneous models, and human-in-the-loop gates to ensure your systems actually finish the job safely and cost-effectively."
The Audit Tool: Add these constraints directly to your SME Consultant Bullshit Detector. When auditing a vendor, ask:

1. "How do you handle context pruning between agent boundaries to prevent instruction drift?" 2. "What deterministic termination conditions are built into your iterative review loops?" 3. "What base models are used for the writing vs. the editing roles to prevent model monoculture groupthink?"

🔗 Related Notes

[[MOC - SME AI Consulting]]
[[The SME Consultant Bullshit Detector]]
[[The Agentic Contract Chain (Auto-Think and Auto-Build)]]
[[From Vibe Coding to Software Factory (7-Agent Workflow)]]