Every multi-agent system looks invincible in the playground.

You wire three LLMs together in a prompt chain. The Strategist drafts a plan. The Writer generates copy. The Critic offers thoughtful feedback. The output reads smoothly, the demo lands with applause, and the architecture diagram looks deceptively clean.

Then you deploy the system to production.

Within forty-eight hours, the cracks appear. Not because the models are unintelligent, but because you built an inter-agent game of telephone.

#The Field Failure of July 22

On July 22, our multi-agent dispatch system encountered its first real stress test.

A Dallas-based emergency HVAC workflow was processing high-volume distress calls during a 104°F heatwave. Three autonomous agents were responsible for customer triage:

• ▸**The Ingestion Agent** transcribed audio packets from customer calls.
• ▸**The Diagnostic Agent** summarized mechanical symptoms (e.g. frozen evaporator coils, humming contactor).
• ▸**The Dispatch Agent** booked emergency slots and populated work orders in ServiceTitan.

Between the Diagnostic Agent and the Dispatch Agent, we used conversational summaries:

"Customer reports AC blowing warm air. Unit is humming outside. Gate code is #4821. Note: Dog is in backyard, technician must access through side gate."

By the time the Dispatch Agent parsed the summary into the final database mutation, the gate code had vanished. The summary compression had classified it as "ancillary conversational detail."

The technician arrived on-site, could not access the backyard, waited twenty-five minutes in a 105° attic van, and aborted the truck roll. Cost to the contractor: **$240 in wasted technician labor and an infuriated homeowner.**

#The Three Iron Rules of Multi-Agent Systems

After that incident, we rebuilt the entire getminions.ai engine around three structural rules:

Rule 1: No Prose Between Agents Agents never pass natural language summaries to one another. The wire format between agents must always be strongly-typed, schema-validated Raw JSON.

Rule 2: Deterministic Binary Validation Never trust an LLM to validate another LLM's output. A compiled Go binary validates every JSON payload against strict Pydantic/Zod schemas before any downstream agent receives it.

Rule 3: Schema Rejection Over Inference If a required field (e.g. `gate_code`, `equipment_model`, `breaker_amperage`) is missing or null, the payload is immediately rejected back to the ingestion source rather than inferred by downstream reasoning models.

{
  "dispatch_id": "DSP-84920",
  "trade": "HVAC",
  "urgency": "EMERGENCY_HEAT",
  "customer": {
    "name": "David Miller",
    "phone": "+1-214-555-0192",
    "gate_code": "#4821",
    "access_notes": "Side gate entrance only, dogs secured indoors"
  },
  "diagnostics": {
    "symptom": "EVAPORATOR_COIL_FREEZE",
    "ambient_temp_f": 104,
    "system_age_years": 8,
    "refrigerant_type": "R-410A"
  },
  "telemetry": {
    "voice_latency_ms": 1420,
    "validation_status": "SCHEMA_LOCKED"
  }
}

#The Physics of 105°F Attics

When you build software for trade contractors in Dallas, Phoenix, or Atlanta, software design isn't academic. It's thermodynamic.

A technician climbing into a 130°F attic at 3:00 PM does not have the patience to decipher an AI agent's chatty prose. They need deterministic fields: part number, capacitor rating, access code, and homeowner authorization.

By replacing conversational summaries with Raw JSON, our inter-agent latency dropped by **68%**, token costs fell by **44%**, and field dispatch errors dropped to exactly **zero**.

#Operator Takeaway

If you are designing multi-agent AI systems in 2026: - Strip the conversational fluff from your inter-agent payloads. - Enforce strict JSON schemas at every boundary. - Let code handle validation, and let models handle perception.

--- *Built by Parvej and Rakib from the getminions.ai engineering team in Dhaka. Test our live dispatcher at getminions.ai.*