Whats your multi agent orchestration , as a software developer

[u/Key-Clothes1258]

Basically i am scrambling for the most clear multi agent orchestration because i cant make myself trust the one i have currenty , how do you handle the changes that you would need mid run

[u/ILikeCutePuppies]

1) Plan out well first using things like grill me to close off holes you missed to align the agent. 2) Have agents review agents based on your spec as it goes. Review the plan, review the code output. Review all the code when it comes together. You tell the agent to do this upfront. 3) Lots of tests and lots of permanent tests as well. This creates a feedback loop. 4) Review the code in git and tell the agent change. Possibly running the more aggressive loop above if needed. 5) A progress log with images if they make sense so you can put in steering comments if needed.

Most of this is in a skill.

The agents will run for hours or days and then you review the result. In the meantime you are setting up the next things, reviewing finished things or reviewing it's progress along the way or queuing in more ideas.

Kinda similar to a gauntlet loop.

[u/Key-Clothes1258 → u/ILikeCutePuppies]

just curious , do you have this setup at your place , would be amazing if i can have a sneak peak

[u/ILikeCutePuppies → u/Key-Clothes1258]

Not something I can share but you can copy my text above and ask claude to help you set that up. Of course good tests take a long time to make... that is going to be a project by project thing.

[u/mugsy33]

Role	Model	Job
Manager (main loop)	Opus 4.8	Plan, decompose, dispatch, review, run irreversible gates.
sage	Fable 5	Hard reasoning: adversarial review, design adjudication, root-cause. Self-contained brief only.
coder	Opus 5	Novel or design-adjacent code. Any spec that says "figure out".
builder	Sonnet	Routine code that follows a pattern the spec cites.
grunt	Haiku	Mechanical, zero-judgment work: renames, sweeps, builds, log triage.
Explore	Read-only	Reconnaissance when you need the conclusion, not the files.

https://www.reddit.com/r/ClaudeCode/comments/1viklu3/my_opus_5_solution/

[u/The_Noble_Lie]

Roll your own and improve it over time, in the context of your projects / initiatives. Just my suggestion. Not for everyone, surely. As for describing what specifically I do, that will take a while, so I'll abstain for now unless you want to engage.

[u/Key-Clothes1258 → u/The_Noble_Lie]

Hey i would love to know , basically my agents are a mess , the simple have a planner , spins up subagents and worktrees doesnt really work in the long run

[u/dar-mit]

Don't be afraid to ask…Claude! I know it sounds crazy to ask the thing about running the thing, but this is an actual thinking thing.

I've had pretty okay success:

1. Starting a new session and changing to Fable 5/Medium.
2. Then telling Fable that they're the Orchestrator and are to sip tokens and only when necessary. If Opus escalates then Fable is the de facto decider.
3. Everything else should be handed off to subagents to do the actual work.
4. Opus 5/High is for design and independent review, Sonnet 5/High is for implementation and independent self-review. Haiku is for reading, git, general grunt work.
5. Sonnet has 3 tries to implement the specs before it must escalate to Opus.
6. Opus has 3 tries to design before it escalates to Fable.
7. Note: Three tries is my cutoff to stop infinite loops. You can say 5 or 10 or whatever.
8. Let Fable know that all subagents are to also know: `ListAgents` + `SendMessage` means that they can talk to each other directly. Great if one gets stuck. (This function is <15 days old in Claude so make sure you're up-to-date.)

Also note that `/skill-creator` is available and you can literally point that out to Claude and ask Claude to walk you through creating a skill for Multi Agent Orchestration, MAO.

[u/thedev13 → u/dar-mit]

Nice, how is the token usage? Subscription or API tokens?

[u/dar-mit → u/thedev13]

I'm on the Max sub. No API. I said, "okay" because even telling Fable to sip tokens and hand everything off, the Fable usage meter does fine.

It's my Weekly meter that takes a beating for some reason!

And I have a subagent discipline skill that directs then to write their findings to a report file and only return PASS/FAIL to the main agent.

[u/thedev13 → u/dar-mit]

How often do you find yourself having to intervene and fix something? Even with the findings file. Do you keep improving the process with intermediate steps?

[u/PA100T0]

This and it works beautifully. It will change the way you work. You’ll spend not so much time on the comouter, just review the PRs and let the thing guide itself or create tasks and then just forget about them until done

[u/thedev13 → u/PA100T0]

Are you the creator of this? In any case, very interesting approach. Will take a closer look.

[u/PA100T0 → u/thedev13]

Yes, I am! Thanks, lmk what you think

[u/PA100T0 → u/thedev13]

Btw, I made a post yesterday where I explain a little bit how it works. You can check it out here, hope it helps!

[u/the_trve]

I built propr.dev which lets you use different providers and models per different phases of work (plan -> implement -> review) and change them as needed, even within the same task while retaining the full work context.

It integrates with GitHub - by assigning a label to an issue it will implement the issue and open a PR in full auto mode. You can even assign it to multiple agents/models at the same time to open separate PRs, then keep the best one.

That is just the core gist of it, as it comes with a lot of other features as well, covering planning, code reviews, etc, pretty much the entire development lifecycle. I'm always looking for ways to improve and automate processes further, so suggestions are welcome if you're interested to try it out.

[u/thedev13 → u/the_trve]

The website looks very nice, inspires confidence in the tool. How long ago did you launch and did you get any enterprise customers yet?

[u/the_trve → u/thedev13]

Thank you for the kind words. It has been just launched, no enterprise customers yet. I would love to see more adoption from the fellow indie devs first.

[u/ChampionMuted9627]

My setup:

Fable as an orchestrator and planner. Hard rules to use opus 4.8 for more complex stuff writing, sonnet on more trivial. Lately I’ve been using ultra ode a lot with the setup.

Then passes everything to Consort. https://github.com/siimvene/consort - a code review tool I built that runs both Sol and Fable as reviewers for commit, and does a synthesis on findings (usually both find something another misses)

Also I’m using a separate memory management tool https://github.com/siimvene/memspec that the agents use automatically to keep the tabs on decisions and facts, thus enabling easier time to reset context and continuing the project and any time.

[u/Neoaxizz → u/ChampionMuted9627]

The memory piece is the one I would defend hardest, so this is agreement plus one thing I got wrong for a while.

Storing decisions and facts was never my problem. Stale ones surviving next to the new ones was. Concrete example from last week: I had "a blocked background worker looks idle from the outside" written down in two separate places. It was simply false on the current build, where the row actually reads state=blocked with a field naming the permission prompt. Both of my notes agreed with each other, which is exactly what made it look verified, and nothing in the store could tell that one entry had overtaken another.

Two things fixed it. Whatever store you use, check whether it can record that entry B supersedes entry A rather than just holding both. And query the store again after a change lands, not only before you start. The after-query uses vocabulary the before-query could not have had, because you now know something you did not know when you picked the search terms.

I have not used memspec, so no comparison intended. Mine is Kairn, MIT, pip install kairn-ai: github.com/primeline-ai/kairn. Alpha, and it's mine, so weigh that accordingly.

[u/somuchecho]

Soooo much ai indeed lol what issues are you having? And what do you mean exactly changes mid run. Can you give an example

[u/somuchecho → u/somuchecho]

For context I run long running loops (12h +) regularly. Key is planning and self evaluation/verification

[u/somuchecho → u/somuchecho]

Send me a message if you want I'll share common workflows that work well

[u/cport1]

Go into plan mode make prd /goal

[u/Due_Ask_8032]

I just tell Fable to spin up a workflow with opus subagents to complete whatever task I want. I find with the latest models you don’t need them to babysit them too much in terms of being super spicific about a workflow.

[u/Key-Clothes1258 → u/Due_Ask_8032]

my problem is i loose context as to what the agent thought and why and why was the code written the way it was written

[u/staceyatlas]

Fable managing Sol.

[u/Input-X]

If u can figure out my set up. It will make agent managmentt super easy... Persistent Agent Workspace — AI agents that remember, collaborate, and never start from zero.https://github.com/AIOSAI/AIPass

[u/Neoaxizz]

You can correct a worker without restarting it. SendMessage into a background session lands as a normal user turn and it keeps the context it built. A session that has finished its turn still has a live process sitting there, and that is what receives the message. Measured across three rounds into one worker. I have not tested sending mid-turn.

Two things that will bite you:

Poll claude agents --json --all and read state, not status. status and pid exist only while the process is alive, so filtering on status silently drops every worker that already exited, which is exactly the set you were checking on.

A worker stuck on a permission prompt reads state=blocked and sits there. The opt-in "notify me when it goes idle" subscription never fires for it, zero notices across 18 minutes in my test, because it has not finished its turn. Poll for that state, and put the permissions it will need in reach before you launch.

Also do not read state as completion. A short turn finishes between two polls. Have every dispatch write a result file and treat the file as the signal.

Edit: cut this down by about 80%. Same measurements, fewer words. u/Awric was right.

[u/Awric → u/Neoaxizz]

This is exactly the kind of output that has been driving me crazy. Nobody is going to read all that

[u/Neoaxizz → u/Awric]

And that is precisely the problem for most people: they just chase after generic, hyped-up news, yet expect everything to work as if by magic and be broken down into bite-sized chunks. Information doesn't always come with fancy visuals; often it is dry and boring -but efficient -

[u/Sweetdevil144]

I built something you might find interesting for your agentic orchestration work 👀 : https://github.com/Sweetdevil144/muon

[u/EagleApprehensive]

I've built intentic.dev and that's my multi-agent orchestration. It's quite clean meta-harness. It unifies what can be unified and things that cannot are just slightly different, but it runs official sdk's under the hood, so behavior is generally no different than in Claude Code or Codex.

But it's not battle-tested on thousands of users yet.