A workflow I find useful is to have multiple CLI agents running in different Tmux panes and have one consult/delegate to another using my Tmux-CLI [1] tool + skill. Advantage of this is that the agents’ work is fully visible and I can intervene as needed.
Have you considered using their command line options instead? At least Codex and Claude both support feeding in new prompts in an ongoing conversation via the command line, and can return text or stream JSON back.
You mean so-called headless or non-interactive mode? Yes I’ve considered that but the advantage communication via Tmux panes is that all agent work is fully visible and you can intervene as needed.
My repo has other tools that leverage such headless agents; for example there’s a resume [1] functionality that provides alternatives to compaction (which is not great since it always loses valuable context details):
The “smart-trim” feature uses a headless agent to find irrelevant long messages for truncation, and the “rollover” feature creates a new session and injects session lineage links, with a customizable extraction of context for the task to be continued.
You're right that vanilla tmux can do all of this, if a human were to use it. tmux-cli exists because LLMs frequently make mistakes with raw tmux: forgetting the Enter key, not adding delays between text and Enter (causing race conditions with fast CLI apps), or incorrect escaping.
It bakes in defaults that address these: Enter is sent automatically with a 1-second delay (configurable), pane targeting accepts simple numbers instead of session:window.pane, and there's built-in wait_idle to detect when a CLI is ready for input. Basically a wrapper that eliminates the common failure modes I kept hitting when having Claude Code interact with other terminal sessions.
I have a similar workflow except I haven’t put time into the tooling - Claude is adept at TMUX and it can almost even prompt and respond to ChatGPT except it always forgets to press Enter when it sends keys. Have your agents been able to communicate with each other with tmux send-keys?
I had the same issue. Subagents are nice but the LLM calling them can’t have a back and forth conversation. I tried tmux-cli and even other options like AgentAPI[0] but the same issue persists, the agent can’t have a back and forth with the tmux pane.
To people asking why would you want Claude to call Codex or Gemini, it’s because of orchestration. We have an architect skill we feed the first agent. That agent can call subagents or even use tmux and feed in the builder skill. The architect is harnessed to a CRUD application just keeping track of what features were built already so the builder is focused on building only.
I find that asking Claude to develop and Codex to review the uncommitted changes will typically result in high-value code, and eliminate all of Claude’s propensity to perpetually lie and cheat. Sometimes I also ideate with Claude and then ask Claude to get ChatGPT’s opinion on the matter. I started by copy-pasting responses but I found tmux to be a nice way to get rid of the middleman.
The idea works well with or without direct integration. You can have a cli agent read arbitrary state of any tmux session and have it drive work through it. I use it for everything from dev work to system debugging. It turns out a portable and callable binary with simple parameters is still easier to use for agents than protocols and skills: https://github.com/tikimcfee/gomuxai
There’s no special support needed; it’s just a bash command that any CLI agent can use. For agents that have skills, the corresponding skill helps leverage more easily. I’ll add that to the README
I have both Codex and Claude subs so I wanted one to be able to consult the other. Also it’s useful when you have a cli script that an agent is iterating on, so it can test it. Another use case is for a CLI agent to run a debugger like PDB in another pane, though I haven’t used it much.
I used to get stuck sometimes with Claude and needing a different agent to take a look and the switch back and forth between those agents is a headache and also you won’t be able to port all the context so thought this might help solve real blockers for many devs on larger projects
I've had good success with a similar workflow, most recently using it to help me build out a captive-wifi debugger[0]. In short, it worked _pretty_ well, but it was quite time intensive. That said, I think removing the human from the loop would have been insanity on this: lots of situations where there were some very poor ideas suggested that the other LLMs went along with, and others where one LLM was the sole voice of reason against the other two.
I think my only real take-away from all of it was that Claude is probably the best at prototyping code, where Codex make a very strong (but pedantic) code-reviewer. Gemini was all over the place, sometimes inspired, sometimes idiotic.
This is exactly why I built Mysti because I used that flow very often and it worked well, I also added personas and skills so that it is easy to customize the agents behavior and if you have any ideas to make the behavior better then please don’t hesitate to share! Happy to jump on a call and discuss it as well
Getting feedback on a plan or implementation is valuable because you get a fresh set of eyes. Using multiple models may help though it always feels a bit silly to me (if nothing else you’re increasing non-determinism because you know have to understand 2 LLM’s quirks).
But the “playing house” approach of experts is somewhere between pointless and actively harmful. It was all the rage in June and I thought people abandoned that later in the summer.
If you want the model to eg review code instead of fixing things, or document code without suggesting improvements (for writing docs), that’s useful. But there’s. I need for all these personas.
I understand. My point is that the personas are generally not a good idea and that there are much simpler and more predictable ways of getting better results.
I get where you're coming from, especially since role playing was so vital in early models in a way that is no longer necessary, or even harmful; however, when designing a complex system of interactions, there's really no way around it. And as humans we do this constantly, putting on a different hat for different jobs. When I'm wearing my developer hat, I have to reason about the role of each component in a system, and when I use an agent to serve in that role, by curating it's context and designating rules for how I want it to behave, I'm assigning it a persona. What's more, I may prime the context user and assistant messages, as examples of how I want it to respond. That context becomes the agent's personality--it's persona.
> Together they debate, challenge each other, and synthesize the best solution
Do they? How much better are multiple agents on your evals, and what sort of evals are you running? I've also research that suggests that more agents degrades the output after a point.
Haven’t done Evals yet but measured on few real world situations where projects got stuck and the brainstorm mode solved it. Definitely running evals is something worth doing and contributions are welcomed
I think what really degrades the output is the context length vs context window limits, check out NoLima
I so want to like these vibe coding agents, and sometimes I do, but it really does kind of suck the joy out of things.
What I was hoping would be that I could effectively farm out work to my metaphorical AI intern while I get to focus on fun and/or interesting work. Sometimes that is what happens and it makes me very happy when it does. A lot of the time, however, it generates code that is wrong, or incomplete (while claiming it is complete), and so I end up having to babysit the code, either by further prompting or just editing the code.
And then it makes a lot of software engineering become "type prompt, sit and wait a minute, look at the code, repeat", which means I'm decidedly not focusing the fun part of the project and instead I'm just larping as a manager who backseat codes.
A friend of mine said that he likes to do this backwards: he writes a lot of the code himself and then he uses Claude Code to debug and automate writing tedious stuff like unit tests, and I think that might make it a little less mind numbing.
Also, very tangential, and maybe my prompting game isn't completely on point here, but Codex seems decidedly bad at concurrent code [1]. I was working on some lock-free data store stuff, and Codex really wanted to add a bunch of lock files that were wholly unnecessary. Oh, and it kept trying to add mutexes into Rust, no matter how many times I tell it I don't want locks and it should use one-shot channels instead. To be fair, when I went and fixed the functions myself in a few spots and then told it to use that as an example, it did get a little better.
[1] I think this particular case is because it's trained on example code from Github and most code involving concurrency uses locks (incorrectly or at least sub-optimally). I guess this particular problem may be more of the fault of American universities teaching concurrent programming incorrectly at the undergrad level.
I find it useful to let one agent come up with a plan after a review and another agent implementing the plan. For example, Gemini reviewing the code, codex writing a plan and then Claude code implementing it
> License: BSL 1.1, free for personal and educational use, converts to MIT in 2030 (would love input on this, does it make sense to just go MIT?)
I LOLd at that. Things in AI space become obsolete much faster. I'd say just go with GPL or AGPL if you don't want proprietary software to be built on top of your code
I created a simple skill in Claude Code CLI that collaborates with Codex CLI. It is just a prompt saved in the skill format. It uses subagents as well.
Honest question. How is Mysti better than a simple Claude skill that does the same work?
The skill would allow Claude Code CLI to call Codex CLI but then Claude Code CLI will need to pass context to Codex which would require writing the context "which causes latency" and this process of writing the context will provide limited context to Codex and also eat up from the main context window. Mysti shares the context which is very different from passing context as a parameter.
Why make it a vscode extension if the point of these 3 tools is a cli interface? Meaning most of the people I know use these tools without VSCode. Is VSC required?
> Meaning most of the people I know use these tools without VSCode.
I guess it depends?
You can usually count on Claude Code or Codex or Gemini CLI to support the model features the best, but sometimes having a consistent UI across all of them is also nice - be it another CLI tool like OpenCode (that was a bit buggy for me when it came to copying text), or maybe Cline/RooCode/KiloCode inside of VSC, so you don't also have to install a custom editor like Cursor but can use your pre-existing VSC setup.
Okay, that was a bit of a run on sentence, but it's nice to be able to work on some context and then to switch between different models inline: "Hey Sonnet, please look at the work of the previous model up until this point and validate its findings about the cause of this bug."
I'd also love it if I could hook up some of those models (especially what Cerebras Code offers) with autocomplete so I wouldn't need Copilot either, but most of the plugins that try to do that are pretty buggy or broken (e.g. Continue.dev). KiloCode also added autocomplete, but it doesn't seem to work with BYOK.
I was a proponent initially of CLI when Claude integration with VSCode required a WSL instance, but now that it is integrated directly into VSCode I feel one grouping of tooling hiccups is now ruled out in my workflow. The only (major) nitpick I have is that it wont let you finish typing and cuts you off when asking whether/how to proceed.
I think it is actually going to happen verrrrry slowly. but it will happen. Many many of my colleagues are understandably resisting. it will take a long time to balance out.
Meh. What I’m doing with coding agents is what I’ve been doing for years: TDD except I use prose to describe what I want instead of writing every line of code and then spend more time in review/qa
Have to keep in mind that what is happening now is basically what was promised decades ago. Never mind 4GL, 5GL, expert systems, and other efforts that went nowhere... even COBOL was created with the intention of making programming look more like natural language.
Often, revolutions take longer to happen than we think they will, and then they happen faster than we think they will. And when the tipping point is finally reached, we find more people pushing back than we thought there would be.
I believe high level languages will be replaced by natural human language, the same way as low level languages replaced by high level languages. It is the natural evolution of development.
On the other hand agentic teams will take over solo agents.
> I believe high level languages will be replaced by natural human languageI believe high level languages will be replaced by natural human language
Ask any human client buying dev work from a web agency how "natural language" spec works out for them.
It's not clear to me at all that "natural language" alone is ideal -- unless you also have near real time iteration of builds. If you do, then the build is a concrete manifestation of the spec, and the natural language can say "but that's not what I meant".
This allows messy natural language to vector towards the solution, "I'll know it when I see it" style.
So, natural language shaping iteratively convergent builds.
Things seem to be heading in the direction of using formal languages to define deterministic behaviour and natural languages to express matters of human taste.
https://github.com/just-every/code "Every Code - push frontier AI to it limits. A fork of the Codex CLI with validation, automation, browser integration, multi-agents, theming, and much more. Orchestrate agents from OpenAI, Claude, Gemini or any provider." Apache 2.0 ; Community fork;
# Plan code changes (Claude, Gemini and GPT-5 consensus)
# All agents review task and create a consolidated plan
/plan "Stop the AI from ordering pizza at 3AM"
# Solve complex problems (Claude, Gemini and GPT-5 race)
# Fastest preferred (see https://arxiv.org/abs/2505.17813)
/solve "Why does deleting one user drop the whole database?"
# Write code! (Claude, Gemini and GPT-5 consensus)
# Creates multiple worktrees then implements the optimal solution
/code "Show dark mode when I feel cranky"
# Hand off a multi-step task; Auto Drive will coordinate agents and approvals
/auto "Refactor the auth flow and add device login"
My similar workflow within Claude Code when it gets stuck is to have it consult Gemini. Works either through Gemini CLI or the API. Surprisingly powerful pattern because I've just found that Gemini is still ahead of Opus in architectural reasoning and figuring out difficult bugs. https://github.com/raine/consult-llm-mcp
Here's a portable binary you drop in a directory to allow agentic cli to cross communicate with other agents, store and read state, or act as the driver of arbitrary tmux sessions in parallel: https://github.com/tikimcfee/gomuxai
Happy to help build said integration with ya, feel free to post an issue, fork, or send me a dm. The tool itself exposes the internal DB as well so others with interest can access logs, context, etc.
Interesting indeed but would it behave the same as Claude code or will it have its own behavior, I think the system prompt is one of the key things that differentiate every agent
Will give it a look indeed, I think one of the challenges with the MCP approach is that the context need to be passed and that would add to the overhead of the main agent. Is that right?
Don’t quote me, but I think the other methods rely on passing general detail/commands and file paths to Gemini to avoid the context overhead you’re thinking about.
Codex CLI can run as MCP server ootb which you can call directly from Claude code. Together with a prompt to ask codex for a second opinion, that works very well for me, especially in code reviews.
This looks great! As someone just starting their coding journey, would using multiple agents (Claude/Gemini) help in learning best practices, or is it better suited for experienced developers for refactoring?
Thanks! You would need to instruct the agents to follow best practices and explain it while developing. Sometimes they get messy but if you use the right instructions/persona/skills then you will get very good results
A final review from experienced developers is always recommended
Interesting, I was trying to implement this using AGENTS.md and the runSubagent tool in vscode. Vscode has not yet the capability to invoke different models as subagent so I plan to fallback to instructing copilot to use copilot-cli and gemini-cli. (I am quite angry about copilot CLI offering only full blown models and not the -mini versions though)
I'm planning to add copilot, cursor and cline but feel free to contribute to the repo if you would like to do that and will look for ways to use the mini versions of the models as well when I integrate copilot CLI
Problem is, Copilot CLI doesn't really supports free or mini models. You have very tight choice of models. This looks like product decision. I understand why they won't allow you to use the free models on CLI, but not being able to use the (pay for) mini models is beyond me.
> Is multi-agent collaboration actually useful or am I just solving my own niche problem?
I often write with Claude, and at work we have Gemini code reviews on GitHub; definitely these two catch different things. I'd be excited to have them working together in parallel in a nice interface.
If our ops team gives this a thumbs-up security wise I'll be excited to try it out when back at work.
Great idea. Whether brainstorm mode is actually useful is hard to say without trying it out, but it sounds like an interesting approach. Maybe it would be a good idea to try running a SWE benchmark with it.
Personally, I wouldn't use the personas. Some people like to try out different modes and slash commands and whatnot - but I am quite happy using the defaults and would rather (let it) write more code than tinker with settings or personas.
Fair enough on personas, I like to activate skills more than personas, for example I activate the auto commit skill to ensure the agent would automatically commit after finishing a feature
Anecdotal experience, but when bugfixing I personally find if a model introduces a bug, it has a hard time spotting and fixing it, but when you give the code to another model it can instantly spot it (even if it's a weaker model overall).
So I can well imagine that this sort of approach could work very well, although agree with your sentiment that measurement would be good.
> Multi agent collaboration is quite likely the future
Autogen from ms was an early attempt at this, and it was fun to play with it, but too early (the models themselves kinda crapped out after a few convos). This would work much better today with how long agents can stay on track.
There was also a finding earlier this year, I believe from the swe-bench guys (or hf?), where they saw better scores with alternating between gpt5/sonnet4 after each call during an execution flow. The scores of alternating between them were higher than any of them individually. Found that interesting at the time.
Thank you so much for sharing Denis! I definitely believe in the that as the world start switching from single agent to agentic teams where each agent does have specific capabilities. do you know of any benchmarks that covers collaborative agents ?
multi-agent collaboration on planning is definitely really valuable. I lean in to gemini's long context and have it set up as a long-term observer who I consult about overall direction, project philosophy, patterns in fail and success, and prioritisation. This gives a different perspective from which to assess other agents' plans.
This is very useful! I frequently copy the response of one model and ask another to review it and I have seen really good results with that approach.
Can you also include Cursor CLI for the brainstorming? This would allow someone to unlock brainstorming with just one CLI since it allows to use multiple models.
Will do. I was thinking of also making the LLMs configurable across the agents. I saw a post from the founder of openrouter that you can use DeepSeek with Claude code and was thinking of making it possible to use more LLMs across agents
Regarding DeepMyst. In the future will offer “optionally” the ability to use smart context where the context will be automatically optimized such that you won’t hit the context window limit “ basically no need for compact” and you would get much higher usage limits because the number of tokens needed will be reduced by up to 80% so you would be able to achieve with a 20 USD claude plan the same as the Pro plan
the "full" mode where agents critique each other seems more interesting than quick synthesis. curious whether you've seen cases where the debate produces something neither model would've suggested alone?
I was working on a project where I tried Claude code to optimize processing of taichi Kernel and it kept using structure that didn’t work with taichi lang limitations so it kept going on a loop, did the same with codex and faced the same issue then tried to have both agents discuss it and it worked! It saved me several hours
For me when it’s front end I usually work with Claude and have codex review. Otherwise I just work with codex… Claude also if I’m being lazy and want a thing quickly
I have been using it for some time and it getting better and better with time in many cases it’s giving better output than other tools the comparison is great feature too keep up the good work
I think you will still pay for 3 times the tokens for a single model rather than 3 but will consolidate payment.
I was thinking to make the model choice more dynamic per agent such that you can use any model with any agent and have one single payment for all so you won’t repeat and pay for 3 or more different tools. Is that in line with what you are saying ?
Neither the original issue (having three models) nor this one (un consolidated payments) have anything to do with the end result / quality of the output.
Executing multiple agents on the same model also works.
I find it helpful to even change the persona of the same agent “the prompt” or the model the agent is using. These variations always help but I found having multiple different agents with different LLMs in the backend works better
I love where you're going with this. In my experience it's not about a different persona, it's about constantly considering context that triggers, different activations enhance a different outcome. You can achieve the same thing, of course by switching to an agent with a separate persona, but you can also get it simply by injecting new context, or forcing the agent to consider something new. I feel like this concept gets cargo-culted a little bit.
I personally have moved to a pattern where i use mastra-agents in my project to achieve this. I've slowly shifted the bulk of the code research and web research to my internal tools (built with small typescript agents).. I can now really easily bounce between different tools such as claude, codex, opencode and my coding tools are spending more time orchestrating work than doing the work themselves.
Thank you and I do like the mantra-agents concept as well and would love to explore adding something similar in the future such that you can quickly create subagents and assign tasks to them
That might be true but if you change the system instructions “which is at the beginning of the prompt” then caching doesn’t hit. So different agents would most likely skip caching unless the last prompt is different then you get the benefit of caching indeed
Not if you optimize the tokens used. This is what DeepMyst actually do, one of the things we offer is token optimization where we can reduce up to 80% of the context so even if you use twice the optimized context you will end up with 60% less tokens.
Note that this functionality is not yet integrated with Mysti but we are planning to add it in the near future and happy to accelerate.
I think token optimization will help with larger projects, longer context and avoiding compact.
With an MCP the agent needs to write the context to be passed to the MCP then the MCP would run the underlying CLI with that context. Mysti works differently by sharing context directly with the CLIs.
I think the main difference is that Mysti consults with agents rather than the underlying LLM and in the future potentially the agents can switch LLMs as well