Official Anthropic tip for Claude Code: stop burning Opus 5.5 context on tasks Sonnet 5.5 can swarm, while Fable 5.1 sits idle spin up an autonomous team with /teams claude --teammates ux,backend,adversary Opus 5.5 acts as the lead architect, scoping architecture and validating pull requests Sonnet 5.5 teammates take... isolated git worktrees and hammer out implementations at medium effort Fable 5.1 monitors the peer-to-peer bus as a dedicated adversary, only stepping in at three critical moments: → before a contract locks: does the frontend payload match the backend schema? → when a test breaks twice: are we patching the bug or just hiding the symptom? → before calling done: what attack surface or edge case did everyone overlook? Sonnet 5.5 builds. Fable 5.1 challenges. Opus 5.5 merges and ships Jev engineering runs the identical pattern one layer down: mechanical decisions that need no reasoning (which file to open, which tool to invoke, retry or abort) execute in 16ms, so the frontier models only wake up when execution paths actually diverge Plan on high. Delegate on medium. Keep the adversary on peer-to-peer call. - the full team setup > Opus 5.5 on high coordinates the session and synthesizes PRs > teammate-ux builds client state inside a separate git worktree > teammate-back writes endpoints and handles Redis atomic locks > teammate-adv runs invariant fuzzing and catches replay vulnerabilities > all teammates communicate directly over peer-to-peer messaging without coordinator drag > tasks.json manages file-level mutex locks so nobody steps on another worktree paste the setup and this prompt into Claude Code below: "Configure my Claude Code workspace for autonomous agent teams: 1. Audit ~/.claude/teams and .claude/teams for teammate profiles fitting ux, backend, and adversary > Generate definitions only for missing roles > Pin model: sonnet, effort: medium for workers, and model: fable for adversary > Assign each worker an isolated git worktree branch to eliminate file conflicts 2. Enable agent teams in ~/.claude/settings.json: > Set CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 > Lock main session effortLevel to high 3. Initialize tasks.json in repo root with atomic file locking, allowing teammates to claim subtasks and resolve contracts directly over inter-agent messaging without coordinator intervention 4. Add a team rule to ~/.claude/CLAUDE.md: teammates must request an adversary security review before opening a pull request for the lead session Show every configuration diff first. Do not apply edits until confirmed" ↳show more

Or just buy the 200 a month plan and blast opus on xhigh nonstop forever on everything

Sonnet 5.5 tends to be more expensive than Opus 5.5 given how inefficient it appears with token usage.

Great idea. My only concern is the lead agent being bloated with context of already completed tasks n wasting tokens

stop burning, start billing

This is great, and been experimental for a while. Works really well but messes up cross model chat via herdr a lot.

The real advantage isn’t having more agents. It’s giving each agent a clearly defined role, independent workspace, and a way to challenge the others before code ships. That’s what makes the system interesting.

说实话这套分层编排的思路是对的，主模型别干杂活。但 /teammates 这种全自动 swarm 我踩过坑，几个人格互相甩锅的时候你根本不知道谁改了哪行😅

opening with "official Anthropic tip" and then dropping a flag syntax we can't verify anywhere is exactly the tell. scoping by model name instead of by role is the part that actually matters here. btw what happens when the adversary teammate just says 'looks fine'?

giving one AI the job of arguing with the other AIs is kinda genius lol

A post titled "Official Anthropic tip" just hit 152,541 views. 2,187 bookmarks. From an account with 594 followers. Think about that. Anthropic's own doc says agent teams are experimental. Off by default. Every teammate is a separate Claude instance, and the doc says token use is significantly higher. The post skipped that part. The /teams command? Not in the doc. The tasks.json mutex locking? Not in the doc. The doc's actual advice for file conflicts: give each teammate different files. Three models. One task. Full price. Read the source before you burn the tokens.

Sonnet builds, Fable argues, Opus merges :)

/teammates这种用法先看清楚权限边界，agent能碰的scope和文件系统要划死

Also use opus 5.5 for the implementer if a task is long the better model will always need less turns and therefore is cheaper

This is a mod now

Over lcomplicated

Routing Opus as lead and Sonnet as the swarm is such a practical cost move 🚀 Curious how you split scoping vs implementation across teammates

the win is assigning Sonnet 5.5 tasks while letting Opus 5.5 scope so you don't waste context on execution

That's great

best tip

I like the ui, what is the tech stack on just the ui there? would like to implement it in my swarm

The /teams split makes sense, but Fable as adversary checking contract locks is the part I'd actually borrow.

opus doing architecture while sonnet does the actual work is just management in a trench coat

teammates这个…adversary角色听起来香，但实际上就是让另一个模型挑刺，挑出来的东西一半是废话一半真有用，得自己筛。

the part about fable only waking up when a contract locks is the most underrated thing here everyone else is fighting over worktrees but the real move is knowing when not to spend the token

Evaluating data science requires comparing it with alternative approaches under realistic constraints from a systems engineering perspective.

with this, I will finally get the results I want from my agents team ty, mate

Ty for docs boss

说一个反直觉的事：多 agent 的真正价值不是并行，是逼你把流程写清楚。 /teams 这类编排一旦拆成角色，谁负责什么就没法含糊。 写不清楚的团队，换多少 agent 都救不了。 你们试过把团队拆成角色跑吗，还是越拆越乱？

'stop burning Opus on tasks Sonnet can swarm' - the real trick for me was just having a cheap model decide when Opus is even needed. still tuning that boundary though.

这套分工省的不是模型单价，而是昂贵模型的注意力预算。前提是任务能清晰切片、接口先冻结；否则多 Agent 的同步、冲突合并和重复验证，可能比单个 Opus 直做更贵。

Opus as lead architect, Sonnet swarming the subtasks — fine. What's the retry story when a teammate fails mid-run? That's where my loops always break.