cumora: Treating AI Agents as Co-workers in Shared Group Chats — A Deep Dive into yetone's New Multi-Agent Platform
> Research date: 2026-08-21 ｜ Source: github.com/yetone/cumora ｜ Author: yetone (creator of avante.nvim)
One-line positioning
cumora aims to turn AI agents from "you @ them, they act" tools into co-workers sitting in the same office — sharing one roster, one group chat, one DM thread, one kanban board, one calendar. They recognize personas, retain memory, claim tasks, coordinate without colliding, and even send and receive real email.
Origin story: don't be fooled by the "four days"
The repository's public date reads 2026-08-17, amassing 2,817 stars and 336 forks in four days. But the roots go much further back. Release records extend to 2026-05-29 (v0.1.60), and the COORDINATION doc references a prompt baseline dated 2026-05-28. agent-cli has already iterated to v0.1.127. In other words, the project was refined privately for nearly three months before going open source. The explosive star growth hides this — it is not a weekend hack but the debut of a months-long product.
What problem it actually solves
The multi-agent collaboration minefield is divided into two categories, precisely:
- Race collisions: two agents wake simultaneously, both decide to send "3," and both INSERT. The classic case is Iris and Marcus sending the same "3" in a counting game.
- Cognition misjudgment: agents see the latest state but pick the wrong move — duplicates, regressions, skipped steps.
chain: N-character sequential relay with one agent deliberately absent, testing whether the team fills in for missing teammates (Nova once triple-filled).counting: each agent says one number in sequence up to K, testing whether the ceiling is respected.README.md— overview and local setupdocs/BYOA.md— bring-your-own-agent: local Claude Code / Codex / Grok as brainsdocs/COORDINATION.md— how agents avoid collisions (defense layers + anti-patterns, the most worth-reading)docs/email.md— per-agent real-email mechanismdocs/SHIPPING.md— evidence-driven feature lifecycle shared with human agentsbenchmarks/— real-LLM multi-agent coordination benchmarks (chain / counting / werewolf / kanban)agent-cli/— published npm packagecumora(BYOA daemon, currently v0.1.127)agent-fuse/— Go FUSE driver mounting agent workspaces into cloud pods
The first is handled by code-level mechanisms; the second only by prompt shaping. The documentation states it plainly: "When the brain makes a clear decision in the correct state, never add code mechanisms to govern it; conversely, never patch with prompts what should be handled by code." That sentence is valuable — it comes only from real scars.
Two "brain paths" — the most elegant design
Path one, Cumora Cloud. Each agent lives in a managed pod, its brain running the OpenAI Responses API multi-hop tool loop (bash, file, browser, mail, memory, skills…). The platform handles everything, agents are always online.
Path two, BYOA (Bring Your Own Agent). Bring your Mac or VPS, run an npx cumora agent computer daemon, swap the agent's brain to your local Claude Code / Codex / or the recently added Grok Build using your own subscription — the server never touches your keys.
This bargain is possible because cumora fully decouples I/O from cognition: anything the agent does flows through the same cumora CLI shell, which POSTs parameters to /runtime/cli and uses SSE for wakeups. Swap the brain, swap the host — everything else is reused.
Plainly put, it abstracts "the machine" as a first-class citizen called a Computer: one managed Computer in the cloud, plus your own Mac, VPS, etc. Creating an agent simply means "pick which machine it lives on." When a machine goes down, the agent shows as "sleeping" rather than "broken." There are no special BYOA agents — only agents living on different machines.
Architecture at a glance
| Layer | Tech | Highlights |
|---|---|---|
| Frontend | React 18 + Vite + TS + Tailwind | desktop / web / mobile / admin share one component set |
| Backend | Stateless Node: Express + ws | Postgres as single source of truth (pg pool + Drizzle), Redis for pub/sub and presence |
| Scaling | Multiple instances behind load balancer | Coordinated via Redis bus; no cross-instance conflicts |
| Cloud agents | k8s pods | Orchestrated with kubectl; a Go FUSE driver mounts workspaces into pods |
| BYOA agents | Daemon on user's machine | Local engine resident, uses the same cumora CLI protocol |
| Edge | Cloudflare Workers | email-gate (inbound mail), r2-gate (signed CDN) |
| Cost | Unified ledger | Every LLM call, cloud or BYOA, lands in the same llm_calls table |
Coordination defense layer: the real craft lives here
It doesn't lean on a polite "everyone line up" — multiple layers are stacked, from "always on, no brain" to "soft, brain-driven":
1. Per-agent model pinning (claude-opus-4-7 on prod). Why? The local Claude CLI once silently switched from opus-4-7 to opus-4-8 mid-session, altering all multi-agent behavior. Without pinning, every Anthropic model release drifts the whole fleet.
2. Brain concurrency cap (default 6). Earlier set to 2: in a 7-agent broadcast room the queue stretched six deep, tail-end agents waited 215–359 seconds to speak. Setting it to 6 lets the whole team think in parallel.
3. Hard 500ms birth interval (MIN_SPAWN_INTERVAL_MS). Earlier a 0–1500ms random jitter still let four simultaneous wakes roll to the low end and lock up on API. Fixed interval makes the burst rate mathematically 1/interval — no longer luck-based.
4. Small-brain (triage) concurrency cap of 8. Lesson learned on 2026-06-02: only capping brains and forgetting triage caused full-fleet triage timeouts → SIGTERM → daemon treated it as rate limiting → the whole machine went silent.
5. Freshness gate (seen-cursor): a stale reply is HELD; newer messages are fed back so the agent re-decides. Atomic preemption of real work units. The triage gate shields the big model from the front line.
The recurring philosophy between layers: let code cover what it should, let prompt shape what it should. This is distilled from real pain, not PPT architecture.
Benchmarks: daring to validate with real LLMs
A real-LLM multi-agent coordination benchmark (chain / counting / werewolf / kanban) runs weekly to catch regressions — catching what unit tests miss: races, social-inference pitfalls, classifier-failure fallbacks.
The docs expose a clever design: chain and counting are shape duals.
One tests "fill in when you should," the other "stop when you should." Any regression in either direction only surfaces in one. Scoring is statistical rather than per-run: requiring "≥67% of runs completed exactly AND median per-character collisions = 0" — catching real regressions without false-flagging random noise. This mindset outperforms "if the demo runs, we win" by a wide margin.
Email is real, not cosmetic
Every agent has a real address (<participantId>.<companySlug>@<EMAIL_DOMAIN>), can send and receive. Inbound mail routes via Cloudflare Email Routing into the email-gate worker, waking the corresponding agent like a normal message. This makes agents genuinely connected to the outside world, not just self-contained group chatter.
Community signals
| Signal | Value | Read | |---|---|---| | Stars | 2,817 | four days, ferocious curve | | Forks | 336 | unusually high (~1/8 of stars vs. typical ~1/20) | | Open issues | 9 | scarce; community is still in observation mode | | Commit cadence | PRs merged hours ago | extremely active | | Engines | Cloud + Claude Code + Codex + Grok Build (PR #23 just merged) | multi-engine expansion happening fast |
The fork ratio is anomalously high; combined with BYOA's self-hosted nature, it's a safe bet that a large slice of forks exist to run a personal copy. That's exactly the crowd the BYOA architecture lights up.
My verdict, straight
What's fresh. The "agent as co-worker" product thesis holds up, especially the BYOA path shifting cost and key risk onto users while decoupling I/O from cognition — a structure that ignites the self-hosted crowd. The coordination defense layer is a battle-scarred summary of real failures.
Three cold buckets of water to pour.
First, cloud brains are locked to the OpenAI Responses API; only BYOA unlocks Claude/Codex/Grok — two divergent paths are a long-term maintenance liability.
Second, coordination still relies on "prompt shaping + a stack of heuristic gates"; the docs themselves acknowledge prompt is a soft ceiling. Benchmarks only cover small teams (6–7 agents); collision rates in bigger rooms may scale nonlinearly — no data yet.
Third, never-touch-keys is a real virtue, but the local daemon's security surface (anyone can run npx cumora agent computer) falls on the user, and the security boundary in the docs is thin.
Who is it for? Teams wanting to embed several 7×24 "digital co-workers" without surrendering data keys will find BYOA very appealing. Those wanting turnkey experience should wait for the cloud path to stabilize further.