Launched this week
MAO
Team up Claude Code, Codex and Grok on one canvas
72 followers
Team up Claude Code, Codex and Grok on one canvas
72 followers
Put Claude Code, Codex, Gemini and Grok on one canvas and let them work as a team. Wire two agents and they talk, delegate and hand back results while you lead. Native on macOS, Linux and Windows, built in Rust. 7-day free trial, no card. Then $20, once.
Free Options
Launch Team
AWS Activate CreditsCredits that fuel your startup’s next milestone
Promoted
Hey PH! Quick question before the pitch: how many agent terminals do you have open right now, and who’s carrying messages between them?
For most of us it’s a few tabs and a clipboard. That’s the job MAO takes off your hands.
MAO is a multi-agent orchestration app. You put your agents on a canvas and wire them together:
Add Claude Code, Codex, Gemini, Grok or OpenCode as live terminals.
Draw a wire between two agents. Now they can talk, ask each other things and hand work back.
Give the lead agent one order. It splits the work, each agent takes its own piece, and you only step in when one of them needs you.
And every agent is yours to shape:
Roles: give each agent a job. Builder and Reviewer come built in, or write your own in Markdown once and reuse it across agents.
Bring your own keys: run agents on your own API keys, your existing logins or a custom endpoint. Got several keys? Pool them in one account and switch to the next one right from the agent. MAO stores them only on your machine.
Skills: MAO ships skills that teach your agents how to work the canvas, so out of the box they know how to message each other, delegate and report back.
It’s native first. I built it in Rust on GPUI, the framework behind Zed, so the canvas stays smooth with a dozen agents running on macOS, Linux and Windows. Your workspaces stay on your machine too.
Try it free for 7 days, no card. If it earns a spot in your workflow, it’s $20, paid once. No subscription.
So I’m curious: what would you wire together first?
Congrats on MAO, Miguel. I usually keep Claude Code and Codex in two tabs and carry things from one to the other by hand. On the canvas, do I hand one agent the other's work directly, or am I still the one moving it across?
@w_fan Hey Fan, thanks :) No need for a direct handoff, the agents handle it on their own ;) Pretty great, isn't it? In this picture (zoomed out), you can see all the agents connected and talking to each other. The only one I need to talk to is the Orchestrator.
I run around 20 Claude Code sessions that message each other. Can I limit what an agent on the canvas is allowed to do? For example, only one dedicated session can deploy?
@jirka_sedlak Yes. Two layers handle it.
What a session may run is enforced by Claude Code’s own permission rules, and MAO lets every session have its own. Each Claude Code account in MAO runs in its own config folder, so give the 19 workers an account whose settings.json denies deploying, for example “permissions”: { “deny”: [“Bash(kubectl apply:)”, “Bash(./deploy.sh:)”] }. Give the deploy session its own account, the only one that holds deploy credentials. You can also set this per agent: in the agent’s settings sheet, add launch arguments like --disallowedTools “Bash(kubectl apply:*)”. MAO never weakens these rules. “Skip permission checks” is a per-agent switch that’s off by default, and you can’t sneak it in through the launch arguments.
Who can ask whom is controlled by the canvas. An agent can only see, message, and hand tasks to the peers and notes it’s connected to. Only an agent you mark as Orchestrator can add or remove those connections. So wire the workers to the deployer, and every deploy goes through that one session, which you can also give a role that spells out its job.
The wired builder/reviewer setup is the part I keep coming back to. When the lead agent splits work and the reviewer hands back, does the reviewer see just the handoff summary, or the builder's full context? I'm curious how you keep that "only the necessary context" boundary from losing the detail a reviewer needs to catch a bad change.
@jcbuilds The reviewer never inherits the builder’s context window, and that’s deliberate. Each agent is its own session with its own context. What crosses a wire is explicit: the task text the lead sends (up to 1 MiB), the result that comes back, and whatever notes and peers that agent is connected to.
Detail doesn’t get lost, because the summary isn’t the source of truth. The repository is. Agents on a canvas work in the same project on disk, or in a git worktree per layer, so the summary only needs to say where to look: which commits, which branch. The reviewer reads the actual diff, runs the tests, and judges the change itself rather than the builder’s account of it. That’s also what keeps it an independent review instead of a reread of the builder’s reasoning.
Two things close the rest of the gap. First, have the builder keep a connected note as it works: what changed, why, which tests ran, and what surprised it. The reviewer reads that note alongside the diff. Second, the wire works both ways. If something doesn’t add up, the reviewer can ask the builder directly, and the builder answers with its full context. Tasks and results have IDs and survive a restart, so that back-and-forth doesn’t get lost either.
I'd start with a builder and a reviewer on the canvas. The connection between them should make it easier to follow who is waiting on whom.
@oleksii_sekundant Hey, thanks for the feedback! I’m working on it, along with an easier way to see the current tasks for each agent. For example, the builder has a list of 5 tasks and the reviewer has a task it’s waiting on. Should be released soon!
Been running Claude Code and Codex in separate windows, manually copying context between them like it's 2018. How does agent handoff work — does it automatically pass context, or is there some setup?
@avinashbussa Yes, agents automatically talk to each other and share only the necessary context, without you having to guide them ;) They can also correct themselves if they notice the information they sent was a mistake.