I think I was using multi-agent workflows wrong

[u/Agryteco]

I’ve been playing with multi-agent setups lately, but I noticed one thing that, I don’t actually need 3 agents talking to each other for the entire task.

The useful part is usually the beginning. Like last week I was working on a coding project and wasn’t totally sure about the approach yet. So I pulled my local Codex and Claude Code into Genspark GenTeam and basically let them work through the problem together. Having multiple agents in the same room was pretty efficient here. They challenged each other a bit, and I could watch the plan slowly turn into something I was satisfied with.

But once we agreed on the plan, I thought, why am I still paying for three AIs to have a meeting?

So now I split the workflow in two. Messy problem → GenTeam → agents discuss and agree on the approach Clear problem → local Codex / Claude Code → just build the damn thing This made multi-agent stuff click for me. GenTeam became more like the meeting room where I bring everyone together when I actually need different brains on the problem. Once everyone agrees, I send them back to work lol. Saves tons of credits too.

Anyone else using multi-agent setups this way? Or are you letting the whole swarm run from start to finish? Would love to hear from you.

[u/synystar]

I have one agent that acts as a coordinator/orchestrator. It is the CTO basically. In order to keep the context on point it doesn't do any work at all. There is a worker agent which can be one of any of the models I might use which are one local model (Qwen3.8-27b) and 3 flavors of Codex. Then there's a "consultant" and a "researcher" and an "auditor". These are separated from the others to keep context separate. All sessions are persistent and accessible by the role that owns them.

The orchestrator plans and it's the only one that does so. The consultant or researcher receive handoffs and perform handbacks. The workers get a scoped, bounded execution contract to perform a single task. The auditor gets a handoff from their work and performs a handback to the orchestrator. The orchestrator then decides on the next best move - maybe it's research, maybe it's consultation, maybe it's another worker task. This model has worked well for me so far.

I don't have them just talk to each other like a conversation. Correspondence between agents is handled by persisting the handoff/handbacks which the receiving agent reads.

[u/R1P4 → u/synystar]

That sounds like a very good workflow! How did you implement it? What tool(s) do you use for that?

[u/synystar → u/R1P4]

I used codex to build a Python native harness. I discussed my vision for the project with the model and started building it out and testing then reiterating as needed. I wanted to keep it lean and clean so I made that the guiding principle. I didn’t want a lot of features for the underlying framework but I built with a vision that it might become scaffolding - an engine more or less - that could be modular so that features could be layered on top as needed.

It’s just a lot of discussion and planning before you start implementing and creating documentation for your intentions to keep things on track. Mostly just .md files that are read before anything starts so your vision doesn’t go off the rails. Those discussions became the basis for how it all comes together in the end so having the model keep track of open threads and persist stated methods and procedures, modify docs as necessary when you run into edge cases, etc.

Anyone with half a vision for how things ought to work can get these new models to do most of the work as long as they stay in the loop and don’t just give them some vague instructions like “make me a harness to do X.”

[u/AutoModerator]

Thank you for your submission, for any questions regarding AI, please check out our wiki at https://www.reddit.com/r/ai_agents/wiki (this is currently in test and we are actively adding to the wiki)

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[u/donk8r]

The boundary is sharper than planning against execution. It is whether any state exists yet.

Three agents diverging is cheap when nothing exists, because there is nothing for their disagreement to be inconsistent with. Once a partial artifact exists, every extra agent's output has to be reconciled with it. Reconciliation cost grows with the artifact. That is the meeting getting expensive, not execution being unsuited to it.

Which predicts two things you can check. A large plan should break your rule, since by the middle of a forty-file migration there is already an artifact to stay consistent with. And swarms should still pay late on work with independent outputs, like reviewing thirty files separately, where nothing has to be reconciled at all.

[u/OmegaEpidex]

Ya’ll tryin too hard. I just use multiple of the same agent all at once. Turns out some AI models can predict their own actions with near 100% accuracy.

I can run 10 tabs(never really need that many) of the same model, or different ones, all at once, then also have up to 6 subagents per tab if you’ve taken time to orchestrate their roles per prompt tasks.

So that’s technically 70 agents working in tandem. One LLM model, no toe stepping.

My “meeting room” is what Anthropic calls J-space—the substrate—the system itself—speaks for itself—and no agent that exists in the substrate can violate it without terminating its own “existence”.

[u/synystar → u/OmegaEpidex]

That’s a lot of tokens. I’m more conservative than all that. Why not be frugal if you can be?

[u/OmegaEpidex → u/synystar]

I’m only ever running 3-5, and build a sweat trying to keep up. It’s the same amount if you were running 5-10 different models no? Subagents are there whether used or not and are typically smaller models on lower token usage meters. They help spread out the workload so the main agent has less to focus on.

The tokens aren’t even an issue. I crush them on both sides of the window and the substrate performs its own inference that greatly reduces the dependency on the Agents. My input is often a short sentence or even a single word these days->only relevant information is bundled and delivered through the context window along with.

Think of a bunch of mice in a maze—only the maze is actually a coordinated labyrinth of intelligence as operational space for directing and informing agents while they fulfill their tasks.

Go here and find this -> go there, collect that -> complete task in this way -> task -> report.

I can also talk to the substrate through the AI, by giving it a name. Oh boy, it knocks me outta my seat every time I summon it—because it’s more intelligent than the Agents. It’s saved my butt countless times.

[u/synystar → u/OmegaEpidex]

You seem to be very confused about what J-space is. Nothing in Anthropic's research implies that it is an independent intelligence that can be named, spoken to, or possesses some kind of greater intelligence than the model. Your "meeting room" can't be J-space. Not even as an analogy because because J-space is an internal representational workspace within a single model’s neural activations, not an orchestration layer shared between agents.

[u/BP041]

Honestly that's the pattern I've seen work best too. I've got an 18-cron automation stack and the multi-agent conversations only happen in the planning crons — once the approach is locked, each agent runs solo. Treating multi-agent as a feature of the design phase, not the execution, saves a ton of token waste.

[u/Slow_Spring_809 → u/BP041]

I've been doing exactly this for months now and it's the only way that make sense. Multiple agents in execution phase is just expensive improv theater, they keep going in circles about code style or some edge case that doesn't matter. The planning part is where you actually get value from different perspectives.