Multi-agent orchestration is just file handoffs with a fancy name

Most startups think multi-agent orchestration means building a complex system. They're wrong. The complexity is in the coordination, not the architecture.

We learned this the hard way when our three-agent content pipeline started dropping tasks randomly. Agent A would finish research, Agent B would start writing, then Agent C would sit there waiting for input that never came. No errors. No failures. Just... silence.

The problem wasn't the agents. It was the handoffs.

Here's what we built instead of a fancy orchestration framework:

// Simple state file approach
{
  "task_id": "content-123",
  "current_stage": "research_complete", 
  "next_agent": "writer",
  "artifacts": {
    "research_data": "./artifacts/research-123.json",
    "outline": "./artifacts/outline-123.md"
  },
  "context": "User wants technical blog post about API design",
  "deadline": "2026-01-15T18:00:00Z"
}

Each agent reads this state file, does its work, updates the file, and moves the baton. No complex message queues. No event buses. Just a shared state file that any agent can read and write.

The magic is in the handoff protocol:

• Agent completes its work → Writes output to artifacts folder
• Updates state file → Changes current_stage and next_agent
• Next agent polls → Sees it's their turn, reads the context
• Picks up where previous agent left off → No context reconstruction needed

We run this with three $9 Haiku instances instead of one $180 Opus session. The research agent uses web search tools. The writer agent uses the content templates. The editor agent uses style guides. Each agent is specialized, focused, and cheap.

Key insight: Orchestration isn't about smart routing or complex workflows. It's about making handoffs so simple that agents can't mess them up.

The state file approach scales better than you'd think. We're running 12 parallel content pipelines now, each with its own state file. When an agent crashes, another agent can pick up the work by reading the state file. When we need to debug, we just look at the state file history.

Most importantly: this works with any agent framework. OpenClaw, LangGraph, even custom scripts. The agents don't need to know about each other. They just need to know how to read and write a JSON file.

The startup-friendly part? You can build this in an afternoon with agents you already have. No new infrastructure. No vendor lock-in. Just a file system and a simple protocol.