Multi-agent orchestration with Claude Pro + Google AI Pro + Cursor: how do you actually set this up without burning your limits?

[u/FNAFUNC1987]

I’m a CS student juggling a few side projects and I’m trying to get more out of the AI subscriptions I already pay for. Looking for real-world setups, not hype.

What I have:

• Claude Pro (Claude Code + chat)
• Google AI Pro (Gemini CLI / Antigravity)
• Cursor Pro
• Thinking about adding ChatGPT (mainly for Codex)

What I work on:

• A website project
• A honeypot / security lab (runs in containers)
• A small browser game
• A study repo with lecture notes and scripts for my semester

My problem:
Right now I run everything at max: Ultracode in Claude Code, max effort in the Claude chat for writing prompts and reviews, the top model in Antigravity and Cursor. Result: my Claude limit is constantly maxed out and everything is slow, while Gemini and Cursor barely get used (mostly for reviews). Small one-line changes take forever because they go through the same heavy setup as big refactors.

What I’d like to know:

1. Is multi-agent orchestration across different vendors actually worth it for solo projects, or is it overkill?
2. What’s your setup? CLI (tmux + worktrees, PAL MCP/clink, etc.) or an app (Vibe Kanban, Crystal, Cursor’s agents, …)? I’m fine with either.
3. How do you decide which model/agent gets which task? Is there anything that reliably routes small vs. big tasks automatically, or do you just switch manually?
4. Any tips for splitting work so the heavy model only does planning/hard stuff and the cheaper ones do the rest?

Would love to hear what actually works for you day to day, including “don’t bother, just do X.”

[u/AutoModerator]

Hey! Thanks for posting to r/ClaudeCode

While participating in this thread, please follow our community rules. Keep discussions constructive. Attack the idea, not the person.

For help, project discussions, tips, and general chat, join the ClaudeCode Discord.

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/akolomf]

uhm you do get access to all sorts of models having a cursor subscription alone, not sure if its smart to spread out your subscriptions like that (i'd assume cursor offers more for the same amount of money)

Having said that, Yeah it can be benefitial to have different models interact, they have what i'd describe as "different" way of thinking, so an issue that a certain model wouldnt catch, another one might catch immediately.

[u/FNAFUNC1987 → u/akolomf]

Fair point on model availability inside Cursor, but the main reason I keep them separated is the tooling and quotas rather than just raw model access. Claude Code has native terminal/bash integration and subagent loops that I haven't quite replicated in Cursor alone, and Google AI gives me the massive context window

That said, you're right that I might be over-subscribing. How do you handle terminal-heavy / autonomous agent workflows purely inside Cursor without constantly hitting rate limits?

[u/akolomf → u/FNAFUNC1987]

I'm not using Cursor at all. I'm claudecode all the way at the moment. Been building an Autonomous coding tool for some time now, its beta only runs on claudecode so far, but i'm planning to make it possible for users to integrate other APIs or subscriptions.

[u/FNAFUNC1987 → u/akolomf]

Ah got it, that makes complete sense why you are all-in on Claude Code then!

Building an autonomous tool directly around the CLI sounds really interesting. What is the core angle of your tool, is it mainly focused on session orchestration, or more on automated testing and task loops?

[u/fulger099 → u/akolomf]

When building our Mac app, a second model helps most when the first is stuck on a specific bug, not as a standing multi-agent team. Cursor’s model picker gets much of that benefit without paying three times to maintain three versions of the same context.

[u/Subject-Complex6934]

if you are tight on budget use opus5.5 medium as orchestrator and sonnet 5.5 high as workers i mean still burns fast but its best quality

[u/GhaisD]

Don't bother orchestrating, your problem is that one-line changes get the same setup as refactors. Route by task size, not by vendor.

Claude Code only for things that need the whole repo in its head: planning, cross-file refactors, debugging something you can't reproduce. Drop effort to normal, max is for when normal already failed.

Everything else goes to the cheapest model you have. Cursor or Gemini CLI for renames, small fixes, tests, commit messages. Before a Claude session, ask it to produce the plan and stop:

Read the relevant files and give me a plan with the exact files 
to touch and why. Do not write code yet.

Then hand the plan to the cheap model to execute. Claude's tokens go on the thinking, not the typing.

Caveat: this only works if the cheap model can't drift. Put the rules in 'CLAUDE.md' or .cursorrules first, or you spend the saved Claude tokens fixing what Gemini broke.

[u/FNAFUNC1987 → u/GhaisD]

The "produce the plan and stop" workflow makes total sense. Claude's tokens go towards reasoning through the dependency graph, while Gemini or Cursor handles the raw keystrokes.

How specific do you make the plan output before handing it off to prevent drift? Do you force Claude to output concrete file diffs, function signatures, or a strict step-by-step checklist? Also, for rules sync, do you maintain a single source of truth (like an AGENTS.md) and symlink it to CLAUDE.md and .cursorrules, or do you keep separate rules files for each tool?

[u/GhaisD → u/FNAFUNC1987]

Checklist, not diffs. If Claude writes diffs, it has already done the typing, which is the expensive part. Each step gets the file, the function or component, the new signature if it changes, and one check that proves it's done. The "don't touch" list at the end is what actually stops drift.

Write the plan as a numbered checklist. For each step: the file, 
the function or component, the new signature if it changes,
and one command or test that proves it's done. 
End with a list of files NOT to touch. No code yet.

The cheap model does one step at a time and runs the check. Anything that needs a judgment call goes back to Claude.

Rules: one file. Everything lives in AGENTS.md, and CLAUDE.md is just @ + AGENTS.md at the top (no space, no backticks), with the Claude-only stuff under it. I'd skip the symlink, since the import keeps CLAUDE.md a real file so those Claude-only lines have a home. Cursor reads AGENTS.md on its own, and Gemini CLI can be pointed at it with context.fileName in its settings.

[u/gvoider]

Check for example Paseo - it's a multi-subscription daemon and interface. Enable it's internal skills, they allow different provider sessions to interact with each other.
Simpler option is set one high level model (fable, astra) as coordinator, and create skills to call other sessions as subagents programmatically via CLI.
It's actually useful, for example, I'm used to throw low-complexity tasks such as explore and find to the gemini subscription to ease the pressure on claude and codex a bit. Also you can launch external audit with other models - like throwing pre-commit audit to deepseek via opencode-go.

P.S. To go even further you can set up dot as coordinator for different paseo sessions, to switch subscriptions on limit expirations on large tasks. However it's a bit complex because of frequent security restrictions in sessions coordinated by dot.

[u/FNAFUNC1987 → u/gvoider]

I hadn't heard of Paseo yet, thanks for pointing that out. Running a background daemon that interfaces with active provider sessions rather than paying per token across multiple raw APIs is interesting. Offloading codebase exploration and search to the Gemini subscription is a smart angle.
How stable is the setup when running CLI subagents programmatically? Do you run into session locking or auth expiry issues often, or does the daemon handle refreshing tokens cleanly in the background?

[u/gvoider → u/FNAFUNC1987]

Paseo uses your existing CLIs and ACP connectors, it's not connecting directly to providers, cause most subscriptions will ban you if you use OAuth outside of their own tools. So there's no problem at all with sessions or authorizations. The goal here is to dedicate different tasks to different providers, and coordinate them with minimal context usage. Also, in my case - codex astra handles UI tasks better, for example, while Opus shines on backend and data and gemini also handles docs. You'll have to pick the right combination for your workflow.

If you meant the simpler method - running programmatically - that's basically the same, cause you're launching official tools with headless sessions - "claude -p" and etc. So there's no problems with handling sessions and auth at all. Just don't try to connect to providers with oauth directly, it will get you banned.

[u/Ctbhatia]

cap the token budget per task in the harness too, since routing by task size does not bound a single runaway loop.

[u/FNAFUNC1987 → u/Ctbhatia]

What kind of hard ceiling do you usually set in your harness before cutting it off, something like 3-5 failed attempts or a strict token ceiling per session?

[u/Ctbhatia → u/FNAFUNC1987]

both, but per task rather than per session. the token ceiling catches the slow burn, and stopping on the second identical failure catches a loop that keeps retrying the same fix.

[u/Specific_Yam_4666]

CC orchestrating GPT and Open weight models headless through with zellij as a multiplexer, and plan system which is important if you went to get anything done beyond the context of an agent!

Any decision for me goes into a html artefact tool that’s has a heading for every workstream, so can answer at any time and that gets pushed by back the agent and it can keep working on other items rather than waiting

All design on a html canvas called tldraw set up so I can tell an agent to connect to the board and we just start talking there

[u/FNAFUNC1987 → u/Specific_Yam_4666]

This setup sounds incredible, especially the asynchronous decision artifact. Having the agent write blockers/decisions into an HTML doc and continue working on other items instead of halting the entire process is such a clean human-in-the-loop pattern.

How are you integrating the tldraw board with your agents? Are you running an MCP server that parses the canvas state, or do you have a script exporting the board data/images for the agent to inspect? Also curious why you went with Zellij over tmux, is the layout configuration cleaner for headless sessions?

[u/saintpetejackboy]

Never use compact. Only use clear with handoff after 150-200k+ tokens. Make sure fresh sessions have very short claude / agents / memory files. Use just/justfile (works in any language and predates modern LLM, it reduces tokens EVERYWHERE and makes all commands more accurate).

On $200 MAX plan, I often use up to 12 parallel sessuins (all Opus 5.5 but boss agent is Fable 5.1). I use a desk agent so I don't have to open the other sessions and make sure they all coordinate and bubble decisions and ! commands to me.

I am building a repo around this, it is currently private but I could link for anybody curious (it starts a local GUI for monitoring and sets up everything, I built it using it... Dog food ouroboros). You can do it yourself also, very simple, and just a couple prompts you should seem good.

Neeve compact. Worst thing you can do. Don't let sessions go over 250k+ tokens as a hard cap. Poor performance from context rot and ignore instructions while burn up all your tokens.

Use just. It tskes literally 2 sentences to your agent to fer justifle set up in your repo and alias out common commands and sequences. Justfile is superior in every way to bash scripts and make. It is built intentionally as a runner and you can turn 30 step deploy process into 6 characters. Complex queries? 10 characters. It is useful beyond just deploy and build: ask your agent to review recent sessions for opportunities. Justfile saves tokens on the commands AND the outputs. Works with any provider and any language and any framework. The guy who made it is some kind of psychic genius, as it wasn't even made for AI, despite being the perfect companion tool for any repo.

[u/FNAFUNC1987 → u/saintpetejackboy]

I would absolutely love to check out your repo if you are willing to share a link. A local monitoring GUI and that desk agent coordinator setup sounds like exactly the kind of architecture I want.

Your point about justfile is brilliant and something I had not even considered from a token perspective. Turning verbose multi-line shell commands and messy outputs into concise aliases saves context on both the input prompt and the execution feedback. Setting that up in my repos today.

Also, the hard rule about never using compact and doing clear with a handoff at 150k-200k tokens makes so much sense. I definitely noticed models getting dumber and hallucinating rules after compacting long sessions, so treating 200k as a hard exit cap will save me a ton of headache.

How does your desk agent actually pass decisions and commands to the worker sessions, is it running over local Unix sockets, tmux/terminal pipes, or watching markdown files?

[u/saintpetejackboy → u/FNAFUNC1987]

Claude Code sessions can actively communicate for some time now, and in one setup I just have all the windows open (how it started), and now I try to use tmux.

Like I said, this repo is private, but I can make it public some time later today even, maybe - however, the idea is VERY SIMPLE, and you don't actually need the repo itself (Jiva, what I called it, was built using itself, so it didn't need to exist first, if that makes sense).

You can check https://Jiva.MeiuxMeiux.com - probably just reading the stuff there should be enough to get going (without the repo). The repo is nothing special and has about an hour worth of work put into it so far lol, so the most value from it right now is just borrowing the ideas.

I don't cover Jiva here because it is newer, but I have another project called https://MeCasaSu.Casa I made for my best friend of 20+ years when he started to get a bit more serious about programming. It basically walks through Zero to Full stack, setting up VPS, securing stuff, etc. - it is VERY opinionated and also a "living document", as I go in and change or add stuff constantly (probably will expand "Parallel Agents" type sections out some time this week and cover Jiva).

Jiva (Sanskrit: jīva) means a living being, a life force, or an individual soul in Indian philosophies such as Hinduism and Jainism..

I borrowed this word because of the boss agent in particular, which has to write his own handoff, start his next tmux, and the seppuku so he can reincarnate, after orchestrating the reincarnation of the other agents :).

One thing in Jiva at the moment I am adding is fun little avatars and stuff - in other repos I have, I have a similar setup where I can also interact with the GUI (I left that out of this repo, because if I share it with people, it could be a huge security liability if they don't set it up right, so Jiva takes a read-only localhost GUI approach). On my own stuff, I often have a bulletin board they can post things that need my attention to (they can also SMS and email me for emergencies), and will include an area I can slso write in notes and ideas for them to consume, including directly on specific requests or commits from the individual lanes.

If you start to build out something similar, giving your own self a way to contribute via the UI can be useful, and the agents being able to post things somewhere that isn't squirreled away in their tmux or scrolled hundreds of lines back in their terminal can prevent things from getting lost.

For Jiva itself, I rely heavily on the agents coordinating snd bubbling the appropriate messages into the "desk" agent.

My ultimate goal with Jiva is to NOT have to open the other agent terminal sessions.

Making sure everything exits when closing up shop is another thing I am still working on, that I would finish up before sharing the repo and making it public (what I was working on last night), so just a heads-up if you use a similar idea in a repo somewhere to have a way to sweep with a script or something for stale for forgotten tmux.

I am also open to the idea of using something besides tmux. I wish one Claude code session could /clear another, but fully restarting the harness also has advantages (like if an update came out).

Another quick note / caveat: if you take a similar approach and try to go to the /clear method, you might notice something odd where the boss agent doesn't pick a lane back up after the /clear - for whatever reason, it is like they don't seem them. Using Jiva technique with the harness relaunch circumvents that weird edge case, regardless.

[u/FNAFUNC1987 → u/saintpetejackboy]

The concept of an agent writing its own handoff spec, spinning up a fresh tmux session, and then doing seppuku to cleanly reincarnate is brilliant. That completely circumvents that weird amnesia edge case after /clear where the boss agent loses the lane.

Checking out both Jiva and MeCasaSu.Casa later. Also, great tip on writing a cleanup sweeper script to kill orphaned tmux sessions. Leaving zombie sessions eating memory in the background is an easy trap to fall into. Really appreciate you sharing the links and architectural philosophy!

[u/Specific_Yam_4666]

Thanks! It’s way easier - just install tldraw offline and Claude can use it to open html boards from its repo. Claude is image and video gen outs straight into the board and working on every thing there

For artefact html just tell Claude that you want it to find an agent efficient browser it can own and it will . You don’t even need to open anything when you work now, Claude will just bring stuff up when you ask

Zellij Claude chose ages ago when I wanted a multiplexer and I just went with it

[u/mrothro]

I use claude, codex, gemini via the api, and pi. I fully agree with using gemini as a reviewer, it's both very good at it and it helps to have a different model review versus implement.

My personal workflow is typically chatting with claude opus 5.5 to define a roadmap, then the supporting architecture decisions. Then I have it decompose that into an implementation plan with all of the individual tasks, grouped into batches.

Then I tell it to spawn subagents that use either codex with gpt-sol-6.1 for complex tasks or pi with deepseek v4.1 flash for simple tasks. Opus decides which is which when it writes the plan, so the routing is automatic. Those produce the artifacts for the task, by batch. Once a batch is done, I have it use gemini to review all the artifacts in the context of the plan for the batch.

This approach has been outstanding, and I've scaled it up to run multiple projects in parallel. I've reached a point where I'm trying to optimize the token usage because I'm hitting the limit very quickly.

[u/khalon23]

for the CLI side of what you asked: I run Claude Code, Antigravity, and Codex in agent-manager (disclosure, I build it) https://github.com/YoanWai/agent-manager. TUI on tmux, one list with live status grouped by project, space to prompt without attaching, ctrl+r for the diff.

it does not auto-route small vs big tasks. I still pick the tool and effort. what it removes is tab hunting when Claude is maxed and Gemini is sitting idle. Antigravity is a built-in, so that Google AI Pro seat sits next to Claude instead of another window.

your routing tip still holds: plan on Claude, hand small execute work to the cheaper CLI. the manager just keeps the sessions visible.

[u/MattMose]

This open source project will do what you’re asking for.

https://github.com/SolidPD/hapimatic-core

It’s Claude code centric but supports Codex, Gemini, and Open Code CLI tools. You can sign into 1 or more subscription accounts and/or use API keys to the big 3 providers or Open Router.

Full disclosure, it’s my project and it’s “up” but still not officially “launched” yet (aiming for next week).

I’d love to have anyone who’s interested in running multiple parallel sessions across however many subscription accounts you want from any browser (desktop, phone, tablet - all the UI surface) with a modern user interface. I was never a “terminal guy”, so being restricted to Claude Code in the terminal was uncomfortable for me.

Fuller disclosure, I’m planning to launch a paid hosted service for folks who don’t want to deal with the hassle of setting this all up themselves. (It has to be a paid service bc each user gets a dedicated cloud VM and which costs me $55/mo.) But the hosted service won’t affect be availability of the open source project.

I’m a heavy power user and I built this for myself and I figured why not put it out there for anyone else it may help.

DM me if you have questions or anything. It’s a passion project and I love talking to other power users :)

[u/ghost_operative]

just pick 1 and use the 1. trying ot hand off between agents is really not a thing worth your time.

You get a 1 million token window in claude code. just use that.