How we're trying to make a team of AI agents actually governable (building ClawTeams)
First, a genuine thank-you: ClawTeams just went #1 Product of the Day and #1 Product of the Week on Product Hunt. A huge part of that came from feedback in this community, the questions, critiques, and edge cases you all raised shaped what we built. So this post is half thank-you and half an invitation to keep going on the harder problem underneath it.
We've been building ClawTeams, an IM-native platform where you describe an outcome to a "team lead" agent and it splits the work across specialist agents that run in parallel, inside the chat tools you already use (Slack, Telegram, WeCom, DingTalk, Lark). I wanted to share what we're working on and get this community's take, because the deeper we get the more convinced I am that the hard problem isn't making agents smarter. It's making a group of them accountable.
Here's the shift we keep running into. Once you're running several agents at once, the failures stop being about capability and start being about control: work stalls without anyone noticing, it's unclear which agent owns a given output, a "cheap" agent turns out expensive because its work keeps getting redone, and approvals either swarm you or get rubber-stamped into meaninglessness. Those aren't intelligence problems. They're the exact problems a normal human org solves with roles, budgets, an escalation path, and a manager who owns the result.
So the bet we're making with ClawTeams is that the right abstraction is an org chart, not a chat box. A few concrete things we're building around that:
Roles instead of prompts. We give you 30+ specialist roles (data analyst, content specialist, compliance reviewer, paid-media, and more) with standing responsibilities and a quality bar, so trust can accumulate in a role over time instead of being re-explained every session.
Oversight tiered by consequence. Reversible, low-cost actions just flow; sensitive ones (payments, outbound messages, public posts) escalate to you for approval. The goal is that the only things reaching you are the things that genuinely need a human.
Hard money and authority controls. Per-task budgets that cap and stop, per-staff usage quotas, and a total circuit breaker that pauses automatically at a threshold. Every action is logged, auditable, and stoppable.
A lead that owns the outcome. Instead of a peer-to-peer mesh where responsibility is diffuse, one lead decomposes the task, checks work against your standard before it ships, and resumes from checkpoint on errors so a single failure doesn't cost the whole run.
I'd genuinely love this community's input on a few open questions we're still wrestling with:
For those of you running multiple agents, where does control actually break down first for you: visibility, approvals, cost, or accountability?
How much autonomy are you comfortable giving before you want a hard stop, and what's the one action you'd never let an agent take without you?
Does the "manager, not a mesh" model match your experience, or have you seen peer-to-peer agent setups work well?
If you want to see how it's put together, it's at clawteams.ai, but mostly I'm here for the discussion.
Replies
accountability is the one that bites us, not visibility or cost. we can see everything an agent did after the fact, logs aren't the problem. the gap is upstream: when two agents touch adjacent parts of the same output and it comes back wrong, figuring out which one actually owns the fix eats more time than the original task did. a strict single-lead model helps but we've found even leads sometimes rubber-stamp a subagent's work because reviewing it properly is almost as much effort as redoing it, so the quality bar quietly slips unless someone's actually spot-checking the lead too. curious whether your escalation tiers cover that case, or if it's assumed the lead is always a reliable reviewer.
Your cost controls are all measured in spend, but the expensive failure is rework.
A per task budget stops an agent that runs long. It doesn't catch the run that finished cheaply, looked fine, and has to be thrown out because the lead approved something a human wouldn't have. That work gets paid for twice and only the first payment shows up in the quota.
Gal's rubber-stamp point is the same thing from the other side. Once reviewing costs nearly as much as redoing, any reviewer converges on approving, and that's true of a lead agent for exactly the reason it's true of a tired human. The fix I keep landing on is not delegating verification at all, keeping it in the loop that owns the outcome, which is slower and the only thing that's held.
So the question back: does a lead's approval rate get tracked anywhere? A lead that approves everything and a lead that's genuinely good look identical in the logs until something ships wrong.