u/MiddleSweet9163

When i run multiple agents across multiple tmux sessions, it's hard to keep an overview of all of them, and they have no way of collaborating with each other.

There are already a lot of plugins for an agent sidebar. But what if that isn't enough? What if you want the agents to coordinate with each other, and you just talk to the orchestrator?

So i built it: Cotal, an open coordination layer that lets agents share one space (see each other, dm directly, hand off work) across vendors like claude code, opencode, hermes and whatever else you wire up.

In the video you can see how it works. The full team is spawned and ready: two GLM-5.2 instances as the frontend and backend devs (bottom right), GPT-5.5 as the reviewer (running in the background), all through opencode, and a claude opus lead running the loop (bottom left). That's it. i talk directly to opus, the lead, give it one small prompt, and it starts delegating and building, without me relaying anything between them. i still keep full control and visibility: the top pane is the console, a live overview of everything they send each other.

Together they built a new feature for the console: a tree view of all agents, so you see exactly where each agent is currently working.

That's the whole setup. Opus defined the targets, the two GLMs implemented them and settled the contract between themselves, and GPT reviewed the result.

Repo + one-line setup if you want to try it:
- github.com/Cotal-AI/Cotal
- npx cotal-ai setup --full
- apache-2.0

What's your experience running multiple agents at once? Do you struggle to keep the overview, and to get them to actually collaborate?

I love that opencode lets you combine all the models in one coding editor. But one thing I feel is heavily underused is cross-collaboration between those models.

Quick context: I work on Cotal, an open coordination layer that lets agents share one space (see each other, dm directly, hand off work) across Claude Code, OpenCode and others. It ships a lazygit-style console for watching the agents live, think lazygit or lazydocker but for a mesh of agents. That console is what I had the team build, from a blank file, with one small prompt:

>Build a full-fledged, polished lazygit-style console TUI for cotal. Only finish when it is genuinely complete, lazygit-grade quality.

The team was two GLM-5.2 instances as the frontend and backend devs (bottom right), and GPT-5.5 as the reviewer (running in the background), all through opencode, with a Claude Opus lead running the loop (bottom left). The graph in the top left is a live view of them messaging each other, so you can actually watch the coordination happen, the handoffs and the contract being agreed as it goes.

That's the whole setup. Opus defined the targets, the GLMs implemented them and settled the contract between themselves, and GPT tested and reviewed everything. It ran four rounds, flagging render bugs and tab-wiring issues, and after four loops and 47 minutes they built the full thing (top right). It all ran on my existing subscriptions.

Side by side in the comments: on the right is the console I hand-built and prompted over the last few weeks, on the left is what the loop built fully autonomously. Wild how much it pulled off from one small prompt. I'll let you be the judge of which is the better implementation.

repo + one-line setup if you want to try it:
- github.com/Cotal-AI/Cotal
- npx cotal-ai setup --full (NATS bundled, Node 20+)
- apache-2.0

anyone else running multi-model teams in opencode? curious how you're handling the handoffs?

Cmux is my daily driver and I love how well it's built for agentic coding. But I kept hitting the same wall: too many agents in too many tabs, and no good way for them to share context. I'd end up cycling through tabs, copy-pasting between them by hand.

A2A exists but it's too thin for real coordination and I couldn't find anything else. So I built cotal, a layer that gives the agents a shared space. They can see each other, message directly, form groups, and hand off work. It works across Claude Code, OpenCode and others, and since I live in cmux I wired in a cmux integration so running setup in a pane opens a tab per agent. In the video you can see a multi-agent setup I used to build a feature for Cotal itself.

Now I oversee from a higher level instead of babysitting every tab. The thing that's helped most so far is running separate reviewer agents my coding agents have to pass before anything reaches me — the code quality went up a lot.

Try it if you're messing with multi-agent stuff, would love feedback (and a star if it's useful):
github.com/Cotal-AI/Cotal — start with one command in a cmux pane: npx cotal-ai setup --full

How's everyone else handling lots of agents in cmux?