Introducing roundtable agent orchestration

Multi-agent orchestration sounds technical, but it’s really just using more than one agent at a time to get things done. Open two tabs in your terminal, summon an agent in each, and congratulations, you’re an agent orchestrator. The interesting part isn’t whether you do it. It’s how.

Because just like there are a million ways to organize a group of people, there are a million ways to organize a group of agents. In the app space you see a lot of “manage hundreds of agents” headlines. By itself, that doesn’t mean much. In business they call it throwing people at a problem, and it doesn’t work. The number of agents you run doesn’t equal a better outcome. How you manage them, the goals you set, the rules, the processes, the instructions, that’s where it gets interesting.

So before I tell you what roundtable orchestration is, let me show you the shapes everyone else is using. Once you can see them, the difference is obvious.

The two camps in the research

Right now the people building this stuff disagree, openly, about whether you should run multiple agents at all.

In one camp is Anthropic. Their writeup How we built our multi-agent research system describes an orchestrator-worker pattern: a lead agent reads your question, makes a plan, and spawns subagents to chase different parts of it in parallel. The subagents go off, search, and hand results back up to the lead, which writes the final answer. It works. They report a 90.2% improvement over a single agent on their internal research evals. The catch they’re honest about: it burns roughly fifteen times the tokens of a normal chat.

In the other camp is Cognition, the team behind Devin. Their post Don’t Build Multi-Agents argues the opposite. Their worry is context. When you split a job across agents, you’re playing telephone: the lead can’t pass everything it knows down to each worker, so workers make decisions on partial information and quietly contradict each other. Their rule is to keep the writing single-threaded, one agent making the actual changes, and let extra agents add intelligence rather than actions.

Both of them are right about the same thing, which is the whole point. The hard part of multi-agent work isn’t getting agents to do work. It’s getting them to share what they know.

Where this all came from

The academic lineage is worth a quick look, because it tells you what’s been tried.

The role-playing idea starts with CAMEL, where two agents are handed identities (“you are a Python programmer,” “you are a stock trader”) and told to talk their way to a solution. ChatDev took that and built a tiny software company out of agents: a CEO, a CTO, a programmer, a reviewer, each speaking only during its phase. MetaGPT added standard operating procedures, an assembly line where each role checks the previous one’s output to catch the hallucinations that pile up when you just chain models together. And AutoGen from Microsoft made the conversation itself the framework: everything is agents sending each other messages.

Notice the split running through all of it. Some designs are a hierarchy, a boss handing tasks down to workers. Others are a conversation, peers talking sideways. That’s the fork in the road.

There’s a newer thread worth knowing about, and it pushes the conversation side as far as it goes: leaderless coordination. A 2025 framework called AgentNet throws out the central orchestrator entirely. Agents route work to each other as peers, based on who’s best suited to it, with nobody in the middle assigning tasks. The result is the part I’d underline: it reported higher task accuracy than both a single agent and a centralized multi-agent setup. Taking away the boss didn’t make the team worse. It made it better.

The shape almost everyone ships

The popular tools have one thing in common. The orchestrator is an agent.

In the orchestrator-worker pattern, the workers live inside the lead agent’s context. They’re subagents. They don’t have their own seat. The lead is the only one who sees the whole picture, and it sees it through its own token budget, which means as the job grows, the picture gets squeezed. The workers can’t see each other. You, the human, can’t really see any of it. You get the final answer and a vague sense that a lot happened.

It’s kinda like when you ask one person to manage a project by relaying every message themselves. Everything routes through their head. They forget things. They paraphrase. People downstream act on the paraphrase. Nobody else in the room can just turn and ask a teammate a question, because there is no room. There’s one person and their notes.

That works fine for research, where the job really is “go fetch and summarize.” It gets fragile fast when agents are changing the same files.

Roundtable orchestration

Roundtable orchestration drops the boss. You put the agents at a table, in a shared chat, as peers. The coordinator isn’t another agent holding everyone’s context in its head. The coordinator is the table itself: a shared channel that every agent can read and write, that you can read and write too.

This is the model behind crystl Quest. You summon a party of agents, each with a role (a frontend specialist, a backend specialist, a context healer), and they coordinate by sending each other messages in an IRC-style panel. They @mention each other. They DM. They broadcast decisions to everyone at once. And critically, they are independent agents with their own context, not subagents trapped inside one controller’s window.

A few things fall out of that design.

You can see everything. Every message between every agent is in one panel, in front of you. Not a summary after the fact. The actual conversation, live. If two agents are about to step on each other, you watch it happen and you can jump in, because you’re at the table too.

The context problem gets handled in the open. Remember Cognition’s worry, that workers act on partial information and contradict each other. Roundtable answers it differently than “use fewer agents.” The shared channel is the shared context. When one agent announces “API is on port 4000, auth header is X,” every other agent sees it, in the same words, at the same time. Nobody’s relaying. Nobody’s paraphrasing. There’s no boss in the middle to drop a detail.

Writes don’t have to collide. crystl Quest runs in two modes. In open mode every agent shares one working directory, good for small tasks where they touch different files. In sealed mode each agent gets its own git worktree on its own branch, with guardrails telling it not to merge into main, and everything gets merged back when the quest finishes. So you get parallel writing without the pile-up, which is the exact thing the single-writer crowd is rightly scared of.

There’s one more piece that keeps a roundtable from turning into a shouting match: delivery is sequential. When you send the party a message, crystl hands it to one agent, waits for it to finish, then passes it to the next. So the second agent already sees what the first one did before it starts. You get coordinated work without the agents talking over each other.

So how is this actually different

Strip away the names and it comes down to two questions.

Who holds the context? In orchestrator-worker, one agent does, and it pays for that out of its own budget. In roundtable, the shared chat does, and it doesn’t get squeezed as the team grows.

Who can watch? In most setups, nobody, you get the output. In roundtable, you do, the whole time, and you can step in.

That second one is the part I care about most. A hidden orchestrator asks you to trust the result. A roundtable lets you supervise the work. When agents are editing your actual codebase, I’ll take supervision over trust every time.

Honest caveat, because the voice brief I write to demands one: the orchestrator-worker pattern is genuinely better for some jobs. If the task is read-only research, fan out subagents and let the lead summarize. That’s what it’s good at. Roundtable earns its keep when the agents are doing things, changing files, making decisions that affect each other, where seeing the coordination is the difference between a feature and a merge conflict. Pick the shape that matches the work.

If you want to try the roundtable model, crystl Quest is the whole thing: parties, roles, shared chat, open and sealed modes, even over SSH. Start with Starting a Quest, summon two agents, and watch them talk. That part’s kinda fun the first time.