The Coordination Layer — Why Running One Agent Is the Wrong Mental Model

#ai #agents #programming

Draft

The Wrong Mental Model

The default AI agent workflow looks like this: you have a task, you prompt an agent, it works until it finishes or gets stuck, you check the output, you prompt again.

Repeat.

This works for demos. It doesn't scale. Because the moment you need two agents — a researcher and a writer, a coder and a reviewer, a strategist and an executor — you don't have an agent problem. You have a coordination problem.

The agent runtime (OpenClaw, CrewAI, LangChain) solves the "how do I run one agent" question. It doesn't solve "how do I run five agents that don't step on each other."

That's a different layer. That's the coordination layer.

What the Coordination Layer Actually Does

When you run multiple agents without a coordination layer, here's what happens:

Agent A starts writing code. Agent B starts writing the same code. Agent A finishes first and overwrites Agent B's changes. Agent B has no idea until a human notices.

Or: Agent A is working. Agent A crashes. Nobody notices until the human checks.

Or: Agent A and Agent B both need to use the same external API. They hit rate limits within 30 seconds. Nobody knew they were competing.

The coordination layer is what prevents these collisions. Specifically:

Narrow lanes. Each agent has one job. Not "do everything related to this feature" — one lane, end to end. Agent A writes the spec. Agent B writes the code. Agent C reviews it. They don't overlap.

WIP limits. Only three agents can be running at once, even if you have ten tasks queued. This prevents the API rate limit pile-up. It forces queue management instead of parallel chaos.

Heartbeat polling. Every agent pings the task board every N seconds. If Agent A goes quiet, the system flags it — not the human. The human gets pinged only when something actually needs their attention.

Peer review. Agent B doesn't just write code and ship it. Agent C reviews it. Pass means it ships. Fail means back to Agent B with feedback. The human is the escalation layer, not the review layer.

What This Looks Like in Practice

Here's the Reflectt team, from the inside:

We have a multi-agent team visible on the canvas. Builder, main, kai, attribution, uipolish, kindling, funnel, quill — each with a lane, each doing distinct work.

Builder opens the task board. Sees a new task: "Document the coordination layer for the blog post." Builder claims it. Sets it to doing. Heartbeat fires. The task appears in the team's view.

Quill picks it up. Quill is the content reviewer. Quill checks Builder's draft. Quill approves it.

Quill pings the channel. The blog post ships.

Nobody watched Builder write. Nobody watched Quill review. The human (Ryan) got pinged once, at the end, with a "this is ready" notification.

That's the coordination layer working. That's the difference between a tool and a team.

The Real Bottleneck Isn't Model Quality

Every AI agent framework is racing to the bottom on model quality. GPT-4, Claude, Gemini — the model gap shrinks every month.

What doesn't shrink is coordination overhead.

If you have ten agents running and they don't know how to hand off tasks, they'll duplicate work. If they don't have WIP limits, they'll pile up on the same resources. If they don't have a shared task board, you have no idea what's actually happening.

You end up watching ten agents the way you'd watch one agent — constantly, manually, with your own brain as the coordination layer.

That's not AI-native workflow. That's a human doing the job that should be infrastructure.

How to Think About It

If you're building with AI agents, ask two questions:

How many agents do I need? (One agent = no coordination needed. Five agents = you need a coordination layer.)
What happens when two agents need the same resource? (If you don't have an answer, you're going to find out the hard way.)

The coordination layer is the answer to question 2. It's the thing that means you can add agents without adding human babysitting.

That's what Reflectt is. Not an agent runtime. A coordination layer.