Anthropic just shipped Agent Teams for Claude Code (https://news.ycombinator.com/item?id=46902368). I've been building the same thing independently for months, but with a different architecture that solves the two biggest problems people flagged in that thread: file conflicts and quality.
Their approach uses file locking. Tasks have to be file-disjoint or agents overwrite each other. CAS uses git worktrees instead. Each agent gets its own full copy of the repo on its own branch. Three agents can edit the same file simultaneously and the supervisor merges everything back. No locks, no file-disjoint constraint.
The other problem: agents that say "done" when they're not. CAS has verification gates. Workers self-verify before closing (no TODOs, code is wired up, tests pass). Tasks enter pending_verification and workers can't claim new work until it clears. This was born out of pain. Without it, agents mark tasks done while leaving half-connected code everywhere.
`cas` launches a TUI with a supervisor. You give it an epic and it takes over: analyzes the tasks, figures out the right implementation phases based on dependencies, determines how many workers can run in parallel without file conflicts, and spawns them. Each task gets a demo statement describing the observable outcome ("User types query, results filter live"). This was the single biggest quality lever I found. Without it, agents default to building layers of plumbing that never connect to a working feature.
For inter-agent messaging, we reverse-engineered Claude Code's Team feature to build a push-based SQLite message queue. The previous version injected prompts by writing raw bytes into the terminal multiplexer. It worked, but barely. Now the supervisor sends a message and the worker's next MCP call picks it up. Clean and reliable.
Workers claim tasks via a lease system (renewed by heartbeat) to prevent double-claiming. The supervisor reviews completed work, merges the branch, syncs remaining workers, and assigns next tasks.
The TUI has side-by-side/tabbed views, session recording/playback, desktop notifications, and detach/reattach. Terminal emulation uses a custom VT parser based on Ghostty's.
Persistent context
CAS also runs as an MCP server (55+ tools) so agents remember things between sessions. 4-tier memory inspired by MemGPT. Rules that earn trust (Draft > Proven > Stale) and auto-sync to .claude/rules/. Full-text search via Tantivy BM25. Everything local in SQLite.
What's hard
Agent coordination is a distributed systems problem wearing a trenchcoat. Stale leases, zombie worktrees, agents that lie about completion. We've added heartbeats, verification gates, and lease expiry, but supervisor quality still varies with epic complexity. The honest answer is this is an ongoing arms race.
I’ve been experimenting with a similar pattern but wrapping it in a “factory mode” abstraction (we’re building this at CAS[1]) where you define the spec once after careful planning using a supervisor agent then you let it go and spin up parallel workers against it automatically. It handles task decomposition + orchestration so you’re not manually juggling tmux panes
After reading Cloudflare's Code Mode MCP blog post[1] I built CMCP[2] which lets you aggregate all MCP servers behind two mcp tools, search and execute.
I do understand anthropic's Tool Search helps with mcp bloat, but it's limited only to claude.
CMCP currently supports codex and claude but PRs are welcome to add more clients.
Problem with skills is that agents have to load the entire skill for them to use it, or you could break down big skills into multiple smaller ones, which is just a hassle compared to cmcp.
With cmcp you get to use all thr available mcps, while still not bloating context.
Kudos to the guy for building such an awesome project in a very short amount of time. Of course he had to take some shortcuts to deliver, but at the end of the day, OpenClaw remains one of the best open source AI assistant implementations.
Exactly, and this is the best way to do code review while it's working so that you can steer it better. It's really weird that Anthropic doesn't get this.
yeah the steering thing is huge - like when you can see it's about to go down the wrong path you can interrupt before it wastes time. or when you realize your prompt wasn't clear enough, you catch it early. hiding all that just means you find out later when it's already done the wrong thing, and then you're stuck trying to figure out what went wrong and how to fix it. it's the difference between collaborative coding and just hoping the black box does what you want
SEEKING FREELANCER | Remote
Needed: Senior React Developer to join us at Nordbeam.
I'm looking for one or two Senior React software engineers to join us at Nordbeam. We're a React/React Native consultancy based in Sweden but we work with remote developers all the time. If interested, apply through here: https://activeinterview.com/interviews/intrv_02uUKEPZcz5Xq1T...
I’ve been using Fly for my new startup that offers notifications as a service [1], and the whole setup is super easy and efficient.
Since fly deploys at the edge closer to the users, our response times for notifications are 20ms on average which is mind blowing since I haven’t spent more than 1 hour on infrastructure setup.
There are many things that can happen to a non-profit that can change the way they provide software or a service. Apart from a sale being possible (albeit with regulator approval), a non-profit could split (see MozillaCorp), or simply act against its own stated interest due to internal politics (see PIR).
Or the change could be smaller such as the non-profit changing focus and transferring one of it's products to another entity. e.g. Signal could hypothetically pivot to focus on crypto lib dev/maintenance and transfer the messaging service maintenance to another org.
Brian Acton, WhatsApp co-founder, one who left Facebook post-acquisition, infused 50M USD into Signal. And, Signal is community-supported through donations. I hope that Signal remains here for a long time.
It is strange he moved from seeing a centralized messenger project he founded be morphed into a monster, only to double down and invest in yet another privacy hostile centralized messaging system hoping for a different result.
Anything not decentralized is going to get abused eventually.
The US government could seize the client signing keys, release s backdoored client, and dump the SGX keys and gag order everything in the name of national security. We have seen similar play out in China. Even the mighty Apple gave up HSM keys and caved to CCP censorship demands. It is only a matter of time.
I fear they are well meaning but woefully naive.
We need censorship resistant standard protocols anyone can implement and help host so there is no SPOF.
Moxie doesn't care about sellout money. As I understand it he wants to run signal as a lifestyle business, and he has private donors keeping everything afloat. I'm not sure if it'll stay independant if Moxie ever leaves, but hopefully there's a stable org structure. Source: The JRE podcast he did a couple months back.
Also if they ever sell out, the server & clients are completely opensource. It wouldn't take much for someone else to fork the whole thing and run a competing service if we ever need to.
Their approach uses file locking. Tasks have to be file-disjoint or agents overwrite each other. CAS uses git worktrees instead. Each agent gets its own full copy of the repo on its own branch. Three agents can edit the same file simultaneously and the supervisor merges everything back. No locks, no file-disjoint constraint.
The other problem: agents that say "done" when they're not. CAS has verification gates. Workers self-verify before closing (no TODOs, code is wired up, tests pass). Tasks enter pending_verification and workers can't claim new work until it clears. This was born out of pain. Without it, agents mark tasks done while leaving half-connected code everywhere.
GitHub: https://github.com/codingagentsystem/cas Website: https://cas.dev
How it works
`cas` launches a TUI with a supervisor. You give it an epic and it takes over: analyzes the tasks, figures out the right implementation phases based on dependencies, determines how many workers can run in parallel without file conflicts, and spawns them. Each task gets a demo statement describing the observable outcome ("User types query, results filter live"). This was the single biggest quality lever I found. Without it, agents default to building layers of plumbing that never connect to a working feature.
For inter-agent messaging, we reverse-engineered Claude Code's Team feature to build a push-based SQLite message queue. The previous version injected prompts by writing raw bytes into the terminal multiplexer. It worked, but barely. Now the supervisor sends a message and the worker's next MCP call picks it up. Clean and reliable.
Workers claim tasks via a lease system (renewed by heartbeat) to prevent double-claiming. The supervisor reviews completed work, merges the branch, syncs remaining workers, and assigns next tasks.
The TUI has side-by-side/tabbed views, session recording/playback, desktop notifications, and detach/reattach. Terminal emulation uses a custom VT parser based on Ghostty's.
Persistent context
CAS also runs as an MCP server (55+ tools) so agents remember things between sessions. 4-tier memory inspired by MemGPT. Rules that earn trust (Draft > Proven > Stale) and auto-sync to .claude/rules/. Full-text search via Tantivy BM25. Everything local in SQLite.
What's hard
Agent coordination is a distributed systems problem wearing a trenchcoat. Stale leases, zombie worktrees, agents that lie about completion. We've added heartbeats, verification gates, and lease expiry, but supervisor quality still varies with epic complexity. The honest answer is this is an ongoing arms race.
Getting started
curl -fsSL https://cas.dev/install.sh | sh cas init --yes && cas
~235K lines of Rust, 17 crates, MIT licensed. Happy to answer questions.
reply