Loading video...

Video Failed to Load

There was a problem loading this video. This could be due to a temporary network issue or the video might be unavailable.

Anthropic just released new agent guide: make every subagent earn its own context steal this 18-role blueprint for turning Opus 5.5 into an entire engineering team PLAN → TOOLS → RESULTS → REVISE one main loop keeps the goal, plan and evidence → procedures become skills → API actions... become tools → reference material loads when needed keep separate workers for fresh parallel research, independent verification or a measured context/tool boundary merge roles that repeatedly share data. compare each fold on the same end-to-end tasks and inspect what breaks official migration kit: > git clone copy its skill/ folder to .claude/skills/single-agent-loop/ then in Claude Code: Run the single-agent-loop skill 18 roles in the map. evidence decides which ones need their own loop save this, then read the full guide for Opus 5.5 Harness Engineering ↓show more

beamnxw ./

14,424 subscribers

18,866 views • 6 days ago •via X (Twitter)

Science & Technology Education

Anya Rossi• Live Now

Private livecam show

28 Comments

beamnxw ./6 days ago

guide: reference kit:

Lummox6 days ago

That’s another step bros

monokern6 days ago

shared context overhead is what people usually underestimate

tekario6 days ago

this guide is what i was looking for this evening!

Bonsai 🌳6 days ago

If there’s anyone you should listen to, it’s definitely Anthropic

Marvin6 days ago

anthropic is an incredibly cool company from what i can see

NO1ennn6 days ago

Alpha info bro , we must test it thx

Lisa Phillips5 days ago

Is mandating context for every subagent truly scalable, or does that overhead introduce complexity that negates the efficiency gains of using a large model?

Diam6 days ago

The merge rule makes sense. Separate job titles don't always need separate agents.

Skaly_Bull6 days ago

A subagent that cannot justify its own context is just expensive noise

Yarchi6 days ago

That’s huge, thanks for sharing

Gipp 🦅6 days ago

anyone scaling teams with agents should dig into this guide

EugBass6 days ago

very helpful guide

Zhen5 days ago

A role earns its own context when it reduces a specific failure mode: stale assumptions, weak verification, or tool sprawl. I’d compare the single-loop baseline and the split version on identical tasks, then inspect both the result quality and the cost of reconciling their state.

0xbobaa6 days ago

"merge roles that repeatedly share data" is the line most multi-agent setups need, half the subagents out there just pass the same context back and forth

Crio Songo6 days ago

This idea is quite interesting, I'll pull the code down and run it to see how the effect actually works.

Vini Ensina | Claude Code & IA6 days ago

the test I use before splitting off a subagent: does it run in parallel, need a clean context, or need tools that conflict with the main loop? if none of the 3, it stays a skill in the main agent. every handoff loses detail

猫屎咖啡6 days ago

子代理各管一摊更清爽

Slonski6 days ago

comparing each merge of roles on the same end-to-end tasks is what really shows what breaks

Javeriya Ahsan5 days ago

Having verifiable outputs changes the whole workflow.

Zephyr6 days ago

curious which of the 18 roles survive after the merge test. my guess is verification stays separate and most of the rest fold into one loop

catman5 days ago

If teams start treating context boundaries as something to measure, agent architectures may get simpler over time. The roles that survive will be the ones that show a repeatable improvement on real tasks, not the ones that look good on a diagram.

Unmarked6 days ago

wtf is this hahaah

Vipul Kumar Kewat5 days ago

If you want to grow, share one lesson per video, not just the video.

AdiiX6 days ago

merge roles that keep sharing data, such a clean rule, saving the whole blueprint Beam

IronaX5 days ago

Thank it’s nice

marfin6 days ago

thx for these links, friend

The SI Maximalist6 days ago

Eighteen roles, one main loop keeping the evidence straight. The org chart gets much more useful when progress survives a handoff.

Related Videos

Official Anthropic tip for Claude Code: Opus 5.5 advises. Sonnet 5.5 builds. Haiku 5.5 investigates turn Claude Code into your own 3-model engineering team 01 Sonnet 5.5 → the builder turns findings into code changes, runs tests, and owns implementation 02 Opus 5.5 → the advisor reviews the approach when a decision needs another pass 03 Haiku 5.5 → the research crew maps the codebase, finds relevant files, and returns useful evidence the clever part: scouts research in separate contexts and bring back findings for the main agent to act on create custom Haiku scouts with: model: haiku tools: Read, Grep, Glob that tool list gives them read-and-search access ↳ [subagent setup] ↳ with Sonnet as your main model, enable Opus advice: /advisor opus the advisor is experimental and uses the Anthropic API ↳ [advisor setup] ↳ add the optional community hooks: npx claude-code-templates@latest --setting hooks/subagents-explore-only --hook security/subagent-read-only-guard SubagentStart → adds research instructions. [instruction hook] ↳ PreToolUse → blocks covered subagent write attempts. [guard hook] ↳ keep the tool allowlist and verify the guard runs; MCP calls are outside its coverage the goal: dedicated researchers, useful advice, and a main agent that owns the code changes the loop: ask → read → search → report → main agent edits → tests save this, then read the full guide for Opus 5.5 Harness Engineering

Official Anthropic tip for Claude Code: Opus 5.5 advises. Sonnet 5.5 builds. Haiku 5.5 investigates turn Claude Code into your own 3-model engineering team 01 Sonnet 5.5 → the builder turns findings into code changes, runs tests, and owns implementation 02 Opus 5.5 → the advisor reviews the approach when a decision needs another pass 03 Haiku 5.5 → the research crew maps the codebase, finds relevant files, and returns useful evidence the clever part: scouts research in separate contexts and bring back findings for the main agent to act on create custom Haiku scouts with: model: haiku tools: Read, Grep, Glob that tool list gives them read-and-search access ↳ [subagent setup] ↳ with Sonnet as your main model, enable Opus advice: /advisor opus the advisor is experimental and uses the Anthropic API ↳ [advisor setup] ↳ add the optional community hooks: npx claude-code-templates@latest --setting hooks/subagents-explore-only --hook security/subagent-read-only-guard SubagentStart → adds research instructions. [instruction hook] ↳ PreToolUse → blocks covered subagent write attempts. [guard hook] ↳ keep the tool allowlist and verify the guard runs; MCP calls are outside its coverage the goal: dedicated researchers, useful advice, and a main agent that owns the code changes the loop: ask → read → search → report → main agent edits → tests save this, then read the full guide for Opus 5.5 Harness Engineering

beamnxw ./

16,148 views • 17 days ago

$this is f*cking goldmine... steal Anthropic's official harness engineering playbook for your Opus 5.5 setup /model + /effort + /context + /usage + /skills = +85.9% efficiency a build loop that saves its progress and knows what comes next ↓ (1/5) → set the effort ▸ /model opus /effort medium use /effort high for deeper verification (2/5) → scope the workers ▸ Opus builds. Haiku handles simple lookups and returns evidence + file paths (3/5) → keep context lean ▸ short CLAUDE.md. skills on demand. compact tool output, full logs on disk (4/5) → save the handoff ▸ feature_list.json + claude-progress.txt + git record what passed and the next action (5\5) → reuse cached input ▸ keep the main model stable. Opus 5.5 effort changes preserve cache with Anthropic API keys or Claude subscriptions /context /usage build → verify → checkpoint → resume save this, then read my article on harness engineering for my AI employee ↓$

this is f*cking goldmine... steal Anthropic's official harness engineering playbook for your Opus 5.5 setup /model + /effort + /context + /usage + /skills = +85.9% efficiency a build loop that saves its progress and knows what comes next ↓ (1/5) → set the effort ▸ /model opus /effort medium use /effort high for deeper verification (2/5) → scope the workers ▸ Opus builds. Haiku handles simple lookups and returns evidence + file paths (3/5) → keep context lean ▸ short CLAUDE.md. skills on demand. compact tool output, full logs on disk (4/5) → save the handoff ▸ feature_list.json + claude-progress.txt + git record what passed and the next action (5\5) → reuse cached input ▸ keep the main model stable. Opus 5.5 effort changes preserve cache with Anthropic API keys or Claude subscriptions /context /usage build → verify → checkpoint → resume save this, then read my article on harness engineering for my AI employee ↓

beamnxw ./

22,670 views • 9 days ago

holy sh*t, Google Research just open-sourced an agent that can improve its own harness steal this blueprint for a self-improving agent the prompts, memory, skills and tool guidance around your model can evolve as it works it’s called Harness² the loop: → propose changes to the agent’s setup → run candidate setups on the same task → compare what actually happened → compose a refined harness from that evidence → carry useful lessons into future tasks the clever part: it refines the harness on unfamiliar tasks without a ground-truth answer to guide those edits the architecture: propose → probe → compose → retain lessons → repeat the part builders should steal: treat your agent’s setup as something you can experiment on pick a recurring failure propose a specific harness change compare execution traces on the same task evaluate the result keep the evidence with the change the repo includes OpenCode and Codex executors, parallel and sequential refinement, and a local demo you can run without model credentials save this, then read the full guide for Opus 5.5 Harness Engineering ↓

holy sh*t, Google Research just open-sourced an agent that can improve its own harness steal this blueprint for a self-improving agent the prompts, memory, skills and tool guidance around your model can evolve as it works it’s called Harness² the loop: → propose changes to the agent’s setup → run candidate setups on the same task → compare what actually happened → compose a refined harness from that evidence → carry useful lessons into future tasks the clever part: it refines the harness on unfamiliar tasks without a ground-truth answer to guide those edits the architecture: propose → probe → compose → retain lessons → repeat the part builders should steal: treat your agent’s setup as something you can experiment on pick a recurring failure propose a specific harness change compare execution traces on the same task evaluate the result keep the evidence with the change the repo includes OpenCode and Codex executors, parallel and sequential refinement, and a local demo you can run without model credentials save this, then read the full guide for Opus 5.5 Harness Engineering ↓

beamnxw ./

11,984 views • 13 days ago

You probably have too many subagents Anthropic team found that one agent with skills often beats a stack of subagents: better quality, lower cost, less latency, easier set up. One customer got about 2x faster runs after switching. Here is the thing. Every subagent hands back a summary, and every handoff loses detail. One agent that saw every step can actually connect them. And since Opus 4.5, models handle far more in a single loop, so a lot of that "router and specialist" structure is doing work the model no longer needs. The old reason to split agents was a bloated system prompt. Skills and tool search fix that: the agent only loads what it needs, when it needs it. Here's how to fold your subagents into one agent: 1. Build the core loop One model, one context window. Each turn it fires off tool calls, the harness runs them in parallel, and the same model decides the next step. Set turn and cost budgets and write gates in the harness. 2. Let the model own the plan It writes the plan on turn one and revises it as results come in. No separate planner, no router. 3. Turn subagent prompts into skills Steps, rules, and team know-how go into skills. The agent only sees short descriptions and loads the full skill when it needs it. That's what keeps the system prompt small: Anthropic cut Claude Code's by 80%+. 4. Turn API calls into tools Group tools by user intent, not one per endpoint. Past 30–50 tool definitions, tool choice degrades, so use tool search with deferred loading. Put validation, approvals, and permissions inside the tools. 5. Move reference material behind search Policies, specs, and docs sit behind a lookup tool the agent calls. Don't paste them into the prompt. Subagents still make sense in a few cases: when the context is measurably bloated, when you need parallel work in fresh context you can throw away afterward, or when the agent keeps picking the wrong tools because of conflicting instructions. Even then, call the subagent as a tool so the main agent stays in the conversation. And don't migrate everything at once. Start with a small eval, even 10 golden examples is enough, then fold in one subagent at a time, beginning with the ones that always run together. Look at which tasks flipped, not just the overall score, and run each task more than once, because some breaks only show up every other run. If the folded version does worse, keep the subagent. Fewer agents, smarter loop.

You probably have too many subagents Anthropic team found that one agent with skills often beats a stack of subagents: better quality, lower cost, less latency, easier set up. One customer got about 2x faster runs after switching. Here is the thing. Every subagent hands back a summary, and every handoff loses detail. One agent that saw every step can actually connect them. And since Opus 4.5, models handle far more in a single loop, so a lot of that "router and specialist" structure is doing work the model no longer needs. The old reason to split agents was a bloated system prompt. Skills and tool search fix that: the agent only loads what it needs, when it needs it. Here's how to fold your subagents into one agent: 1. Build the core loop One model, one context window. Each turn it fires off tool calls, the harness runs them in parallel, and the same model decides the next step. Set turn and cost budgets and write gates in the harness. 2. Let the model own the plan It writes the plan on turn one and revises it as results come in. No separate planner, no router. 3. Turn subagent prompts into skills Steps, rules, and team know-how go into skills. The agent only sees short descriptions and loads the full skill when it needs it. That's what keeps the system prompt small: Anthropic cut Claude Code's by 80%+. 4. Turn API calls into tools Group tools by user intent, not one per endpoint. Past 30–50 tool definitions, tool choice degrades, so use tool search with deferred loading. Put validation, approvals, and permissions inside the tools. 5. Move reference material behind search Policies, specs, and docs sit behind a lookup tool the agent calls. Don't paste them into the prompt. Subagents still make sense in a few cases: when the context is measurably bloated, when you need parallel work in fresh context you can throw away afterward, or when the agent keeps picking the wrong tools because of conflicting instructions. Even then, call the subagent as a tool so the main agent stays in the conversation. And don't migrate everything at once. Start with a small eval, even 10 golden examples is enough, then fold in one subagent at a time, beginning with the ones that always run together. Look at which tasks flipped, not just the overall score, and run each task more than once, because some breaks only show up every other run. If the folded version does worse, keep the subagent. Fewer agents, smarter loop.

Yarchi

16,479 views • 8 days ago

this is pure f*cking treasure 10 connected parts for a serious Opus 5.5 harness context. skills. tools. permissions. hooks. review. effort. goals. state. recovery (1/10) CLAUDE.md > give the project its facts, conventions, source requirements, and output paths (2/10) reusable skills > save the procedure: create the output, check it, record what happens next (3/10) MCP > connect the tools your task needs and retrieve one known source before relying on them (4/10) permissions > use /permissions to inspect the effective allow, ask, and deny rules (5/10) PreToolUse hooks > inspect the proposed tool call and its arguments before execution (6/10) evidence reviewer > configure a focused read/search worker that returns claim, verdict, source, and correction (7/10) reasoning effort > start the main run at medium; give difficult review work its own assignment at high (8/10) /goal > define the required outputs and checks, then surface the evidence in the conversation (9/10) progress.md > save completed work, decisions, open issues, and the next action after each meaningful stage (10/10) checkpoints + Git > use /rewind for tracked file edits and Git for durable history start the session: claude --model claude-opus-5-5 --effort medium the loop: load context → run the skill → use the tools → review the result → prove completion → save progress → resume save this, then read the guide for Opus 5.5 Harness Engineering ↓

this is pure f*cking treasure 10 connected parts for a serious Opus 5.5 harness context. skills. tools. permissions. hooks. review. effort. goals. state. recovery (1/10) CLAUDE.md > give the project its facts, conventions, source requirements, and output paths (2/10) reusable skills > save the procedure: create the output, check it, record what happens next (3/10) MCP > connect the tools your task needs and retrieve one known source before relying on them (4/10) permissions > use /permissions to inspect the effective allow, ask, and deny rules (5/10) PreToolUse hooks > inspect the proposed tool call and its arguments before execution (6/10) evidence reviewer > configure a focused read/search worker that returns claim, verdict, source, and correction (7/10) reasoning effort > start the main run at medium; give difficult review work its own assignment at high (8/10) /goal > define the required outputs and checks, then surface the evidence in the conversation (9/10) progress.md > save completed work, decisions, open issues, and the next action after each meaningful stage (10/10) checkpoints + Git > use /rewind for tracked file edits and Git for durable history start the session: claude --model claude-opus-5-5 --effort medium the loop: load context → run the skill → use the tools → review the result → prove completion → save progress → resume save this, then read the guide for Opus 5.5 Harness Engineering ↓

beamnxw ./

10,238 views • 15 days ago

THIS IS A PURE F*CKING GOLDMINE Anthropic just shared one of the best tricks for Claude Code. The idea: let Opus 5.5 write the plan as a script, and let a swarm of cheaper agents run it. Bigger jobs and way fewer Opus tokens, because the script holds the plan and Opus only sees the final answer. You just launch Claude Code like this: claude --model opus --effort ultracode here's the split: → Opus 5.5 turns your task into a workflow script → Haiku 5.5 agents scan every file in parallel → Sonnet 5.5 agents patch each fix in its own isolated copy → you stop burning Opus context on a hundred agent transcripts Opus only shows up at three moments: → writing the workflow before the run → reading the verified results after it → signing off before anything ships Opus plans. Haiku scans. Sonnet ships. JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to JEV in milliseconds, and the big models only see the ones that split the full tree > Opus 5.5 runs the main session and writes the workflow > scan audits every file on Haiku 5.5 > edit patches each fix on Sonnet 5.5 in an isolated copy > verify cross-checks every finding on Sonnet 5.5 > Opus 5.5 reads only what survived verification > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Run the main session on Opus 5.5 with ultracode on. 2. In every workflow, run read-only scan stages on Haiku 5.5 and edit stages on Sonnet 5.5, each edit in its own isolated copy. 3. Add one rule to CLAUDE.md: every finding gets an independent verifier agent before it's reported, and fix loops stop after two rounds with no progress. 4. Route fast deterministic forks (tool choice, path selection, retries) through JEV. Show me every change as a diff first. No edits until I say go." ↳ save it, it'll come in handy.

THIS IS A PURE F*CKING GOLDMINE Anthropic just shared one of the best tricks for Claude Code. The idea: let Opus 5.5 write the plan as a script, and let a swarm of cheaper agents run it. Bigger jobs and way fewer Opus tokens, because the script holds the plan and Opus only sees the final answer. You just launch Claude Code like this: claude --model opus --effort ultracode here's the split: → Opus 5.5 turns your task into a workflow script → Haiku 5.5 agents scan every file in parallel → Sonnet 5.5 agents patch each fix in its own isolated copy → you stop burning Opus context on a hundred agent transcripts Opus only shows up at three moments: → writing the workflow before the run → reading the verified results after it → signing off before anything ships Opus plans. Haiku scans. Sonnet ships. JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to JEV in milliseconds, and the big models only see the ones that split the full tree > Opus 5.5 runs the main session and writes the workflow > scan audits every file on Haiku 5.5 > edit patches each fix on Sonnet 5.5 in an isolated copy > verify cross-checks every finding on Sonnet 5.5 > Opus 5.5 reads only what survived verification > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Run the main session on Opus 5.5 with ultracode on. 2. In every workflow, run read-only scan stages on Haiku 5.5 and edit stages on Sonnet 5.5, each edit in its own isolated copy. 3. Add one rule to CLAUDE.md: every finding gets an independent verifier agent before it's reported, and fix loops stop after two rounds with no progress. 4. Route fast deterministic forks (tool choice, path selection, retries) through JEV. Show me every change as a diff first. No edits until I say go." ↳ save it, it'll come in handy.

xsmryze

60,847 views • 11 days ago

THIS IS A PURE F*CKING GOLDMINE Anthropic just shared the sharpest trick for Claude Code The idea: let Opus 5.5 write the plan as a script, and swarm the new Haiku 5.5 in parallel Huge sweeps with zero Opus burn: the script holds the loop and Opus only sees the final diff You just launch Claude Code like this: claude --model opus --effort ultracode here's the split: → Opus 5.5 turns your objective into an executable workflow script → Haiku 5.5 swarms every file in parallel at 340 tok/s to extract candidates → Sonnet 5.5 patches each fix and cross-checks findings in its own isolated copy → you stop burning Opus context on a hundred agent transcripts Opus only shows up at three moments: → authoring the workflow script before the run → reading verified findings after the swarm finishes → signing off before anything ships to git Opus plans · Haiku scans · Sonnet ships JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to JEV in milliseconds, and the big models only see the ones that split the full tree > Opus 5.5 runs the main session and writes workflow.js > pipeline() fans out the new Haiku 5.5 to audit every file > parallel() schema validators drop false positives in V8 > Sonnet 5.5 patches each fix in an isolated worktree > verify cross-checks all diffs before reporting > Opus 5.5 reads only what survived verification > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Run the main session on Opus 5.5 with ultracode on 2. In every workflow, run read-only scan stages on the new Haiku 5.5 and edit stages on Sonnet 5.5, each edit in its own isolated copy 3. Add one rule to CLAUDE.md: every finding gets an independent verifier agent before it's reported, and fix loops stop after two rounds with no progress 4. Route fast deterministic forks (tool choice, path selection, retries) through JEV Show me every change as a diff first, no edits until I say go" ↳ save it, it'll come in handy

THIS IS A PURE F*CKING GOLDMINE Anthropic just shared the sharpest trick for Claude Code The idea: let Opus 5.5 write the plan as a script, and swarm the new Haiku 5.5 in parallel Huge sweeps with zero Opus burn: the script holds the loop and Opus only sees the final diff You just launch Claude Code like this: claude --model opus --effort ultracode here's the split: → Opus 5.5 turns your objective into an executable workflow script → Haiku 5.5 swarms every file in parallel at 340 tok/s to extract candidates → Sonnet 5.5 patches each fix and cross-checks findings in its own isolated copy → you stop burning Opus context on a hundred agent transcripts Opus only shows up at three moments: → authoring the workflow script before the run → reading verified findings after the swarm finishes → signing off before anything ships to git Opus plans · Haiku scans · Sonnet ships JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to JEV in milliseconds, and the big models only see the ones that split the full tree > Opus 5.5 runs the main session and writes workflow.js > pipeline() fans out the new Haiku 5.5 to audit every file > parallel() schema validators drop false positives in V8 > Sonnet 5.5 patches each fix in an isolated worktree > verify cross-checks all diffs before reporting > Opus 5.5 reads only what survived verification > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Run the main session on Opus 5.5 with ultracode on 2. In every workflow, run read-only scan stages on the new Haiku 5.5 and edit stages on Sonnet 5.5, each edit in its own isolated copy 3. Add one rule to CLAUDE.md: every finding gets an independent verifier agent before it's reported, and fix loops stop after two rounds with no progress 4. Route fast deterministic forks (tool choice, path selection, retries) through JEV Show me every change as a diff first, no edits until I say go" ↳ save it, it'll come in handy

mirku

200,753 views • 17 days ago

Opus 5.5 makes this AI stack look f…cking illegal 10 GitHub repos for building everything around the model 01 zen-mcp-server ▸ → your agent debates Gemini, GPT and local models mid-task 02 claude-context ▸ → semantic code search so the agent stops grepping blind 03 wshobson/agents ▸ → a roster of subagents, each with one narrow job 04 mcp-agent ▸ → workflow patterns built around MCP tools, not around chat 05 Backlog.md ▸ → tasks live in git, so the agent and you read the same board 06 Claude Code Development Kit ▸ → hooks, subagents and MCP wired for context at scale 07 agent-rules ▸ → shared guardrails the agent inherits in every repo 08 Agent Skills ▸ → one file that teaches the agent a job, portable across tools 09 agent-scan ▸ → scans your agents, MCP servers and skills for what leaks 10 awesome-claude-code-toolkit ▸ → the map: agents, skills, commands, hooks, MCP configs the architecture: rules → context → subagents → tools → state → review → scan I'd split the stack like this: context: claude-context → Development Kit work: wshobson/agents → mcp-agent → zen-mcp-server state: Backlog.md safety: agent-rules → Agent Skills → agent-scan everyone posts the SDK and the CLI the layer that decides whether your agent survives a week is this one the model is one folder in the stack ⭣

Opus 5.5 makes this AI stack look f…cking illegal 10 GitHub repos for building everything around the model 01 zen-mcp-server ▸ → your agent debates Gemini, GPT and local models mid-task 02 claude-context ▸ → semantic code search so the agent stops grepping blind 03 wshobson/agents ▸ → a roster of subagents, each with one narrow job 04 mcp-agent ▸ → workflow patterns built around MCP tools, not around chat 05 Backlog.md ▸ → tasks live in git, so the agent and you read the same board 06 Claude Code Development Kit ▸ → hooks, subagents and MCP wired for context at scale 07 agent-rules ▸ → shared guardrails the agent inherits in every repo 08 Agent Skills ▸ → one file that teaches the agent a job, portable across tools 09 agent-scan ▸ → scans your agents, MCP servers and skills for what leaks 10 awesome-claude-code-toolkit ▸ → the map: agents, skills, commands, hooks, MCP configs the architecture: rules → context → subagents → tools → state → review → scan I'd split the stack like this: context: claude-context → Development Kit work: wshobson/agents → mcp-agent → zen-mcp-server state: Backlog.md safety: agent-rules → Agent Skills → agent-scan everyone posts the SDK and the CLI the layer that decides whether your agent survives a week is this one the model is one folder in the stack ⭣

rody

18,089 views • 1 month ago

Anthropic engineer, Boris Cherny: "At Anthropic, 90% of our engineers are running agents with self-improving loops. in 1-2 months, everyone will be running /loops + /harness - this is the future of engineering" in a 1-hour podcast, Boris Cherny reveals the best tips for building Claude Code automations. Opus 5.5 + loops + harness + dynamic workflows = the secret. Watch it, then read the full guide for Opus 5.5 loop + jev engineering

Anthropic engineer, Boris Cherny: "At Anthropic, 90% of our engineers are running agents with self-improving loops. in 1-2 months, everyone will be running /loops + /harness - this is the future of engineering" in a 1-hour podcast, Boris Cherny reveals the best tips for building Claude Code automations. Opus 5.5 + loops + harness + dynamic workflows = the secret. Watch it, then read the full guide for Opus 5.5 loop + jev engineering

shikamaru

15,204 views • 19 days ago

THIS IS AN ABSOLUTE F*CKING GOLDMINE Anthropic just shared one of the best tricks for Claude Code. The idea: Opus 5.5 writes the entire plan as a script, and a swarm of cheaper agents executes it. Bigger jobs and far fewer Opus tokens, because the script holds the plan and Opus only sees the final answer. You just start Claude Code like this: claude --model opus --effort ultracode here's the split: → Opus 5.5 turns your task into a workflow script → Haiku 5.5 agents scan every file in parallel → Sonnet 5.5 agents patch each fix in its own isolated copy → you stop burning Opus context on a hundred agent transcripts Opus only steps in at three moments: → writing the workflow before the run → reading the verified results after it → signing off before anything ships Opus plans. Haiku scans. Sonnet ships. JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to JEV in milliseconds, and the big models only see the ones that split the full tree > Opus 5.5 runs the main session and writes the workflow > scan audits every file on Haiku 5.5 > edit patches each fix on Sonnet 5.5 in an isolated copy > verify cross-checks every finding on Sonnet 5.5 > Opus 5.5 reads only what survived verification > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Run the main session on Opus 5.5 with ultracode on. 2. In every workflow, run read-only scan stages on Haiku 5.5 and edit stages on Sonnet 5.5, each edit in its own isolated copy. 3. Add one rule to CLAUDE.md: every finding gets an independent verifier agent before it's reported, and fix loops stop after two rounds with no progress. 4. Route fast deterministic forks (tool choice, path selection, retries) through JEV. Show me every change as a diff first. No edits until I say go." ↳ save it, you'll reach for it on every big task.

THIS IS AN ABSOLUTE F*CKING GOLDMINE Anthropic just shared one of the best tricks for Claude Code. The idea: Opus 5.5 writes the entire plan as a script, and a swarm of cheaper agents executes it. Bigger jobs and far fewer Opus tokens, because the script holds the plan and Opus only sees the final answer. You just start Claude Code like this: claude --model opus --effort ultracode here's the split: → Opus 5.5 turns your task into a workflow script → Haiku 5.5 agents scan every file in parallel → Sonnet 5.5 agents patch each fix in its own isolated copy → you stop burning Opus context on a hundred agent transcripts Opus only steps in at three moments: → writing the workflow before the run → reading the verified results after it → signing off before anything ships Opus plans. Haiku scans. Sonnet ships. JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to JEV in milliseconds, and the big models only see the ones that split the full tree > Opus 5.5 runs the main session and writes the workflow > scan audits every file on Haiku 5.5 > edit patches each fix on Sonnet 5.5 in an isolated copy > verify cross-checks every finding on Sonnet 5.5 > Opus 5.5 reads only what survived verification > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Run the main session on Opus 5.5 with ultracode on. 2. In every workflow, run read-only scan stages on Haiku 5.5 and edit stages on Sonnet 5.5, each edit in its own isolated copy. 3. Add one rule to CLAUDE.md: every finding gets an independent verifier agent before it's reported, and fix loops stop after two rounds with no progress. 4. Route fast deterministic forks (tool choice, path selection, retries) through JEV. Show me every change as a diff first. No edits until I say go." ↳ save it, you'll reach for it on every big task.

Callan

13,976 views • 17 days ago

Anthropic engineer: "The fastest way to make an agent better isn't a smarter model, it's the right loop and graph around it." In 60 minutes she breaks down how Anthropic engineers use Claude Code, build agents that catch their own mistakes and improve with every run. This beats any $500 agentic engineering course you can find. Watch it, then read the full guide on loops and graphs below.

Anthropic engineer: "The fastest way to make an agent better isn't a smarter model, it's the right loop and graph around it." In 60 minutes she breaks down how Anthropic engineers use Claude Code, build agents that catch their own mistakes and improve with every run. This beats any $500 agentic engineering course you can find. Watch it, then read the full guide on loops and graphs below.

Anatoli Kopadze

136,422 views • 2 months ago

Anthropic just released 5 Claude workshops on the new skill every AI builder needs: Loop Engineering: 00:00 - Stop babysitting your agents 37:07 - Build a proactive Claude Code loop 1:11:23 - Build a production-ready Managed Agent 1:38:46 - Teach agents to learn from your team 2:07:15 - Hill-climb your agent with eval loops It is a 2 hour and 25 minute blueprint for Loop Engineering: proactive workflows, managed agents, team feedback, evals, and self-improvement. Watch it today, and read the article below to improve your skills with Fable 5.

Anthropic just released 5 Claude workshops on the new skill every AI builder needs: Loop Engineering: 00:00 - Stop babysitting your agents 37:07 - Build a proactive Claude Code loop 1:11:23 - Build a production-ready Managed Agent 1:38:46 - Teach agents to learn from your team 2:07:15 - Hill-climb your agent with eval loops It is a 2 hour and 25 minute blueprint for Loop Engineering: proactive workflows, managed agents, team feedback, evals, and self-improvement. Watch it today, and read the article below to improve your skills with Fable 5.

Alex

47,626 views • 3 months ago

Google just released a 1-hour course on “Context Engineering” for AI agents from scratch: • 00:00 - Introduction to “Context Engineering” • 03:02 - Context Engineering vs “prompting” • 16:18 - Build a context brain for your agent • 22:10 - Building agent context (tools, skills) • 29:06 - Agentic memory bank from scratch This 1-hour watch could replace a $500 course on agentic design. Watch it today, then read the full guide on Context Engineering in the article below.

Google just released a 1-hour course on “Context Engineering” for AI agents from scratch: • 00:00 - Introduction to “Context Engineering” • 03:02 - Context Engineering vs “prompting” • 16:18 - Build a context brain for your agent • 22:10 - Building agent context (tools, skills) • 29:06 - Agentic memory bank from scratch This 1-hour watch could replace a $500 course on agentic design. Watch it today, then read the full guide on Context Engineering in the article below.

Movez

14,923 views • 3 months ago

THIS IS PURE F*CKING GOLD Anthropic just dropped the ultimate autonomy loop for Claude Code The idea: run /goal in auto mode, and let the new Haiku 5.5 judge every turn True overnight autonomy with zero burn: Sonnet builds, Haiku evaluates at 340 tok/s, Opus signs off You just launch Claude Code like this: claude --model opus --dangerously-skip-permissions here's the split: → Opus 5.5 locks the goal condition and plans the overall architecture → Sonnet 5.5 writes the fixes, refactors modules, and runs test suites → Haiku 5.5 evaluates completion after every turn as an independent Stop hook → you stop burning Opus context on dozens of intermediate iteration turns Opus only shows up at three moments: → framing the goal condition before the loop starts → intervening if the loop hits the turn cap or an impossible verdict → signing off on the final git diff once the goal clears Opus frames · Sonnet builds · Haiku judges JEV engineering is the same move one layer down: the forks that need no thinker (which tool, path resolution, retry or abort) clear in milliseconds, and the big models only see the ones that split the full tree > Opus 5.5 runs the main session and defines the completion condition > auto mode approves safe tool calls so turns run unattended > Sonnet 5.5 patches code and runs test suites in an isolated copy > Haiku 5.5 evaluates transcript evidence: Met · Not yet met · Impossible > background check-in monitors idle tasks and backs off stuck loops > Opus 5.5 reviews the achieved transcript and signs off on the diff > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Run the main session on Opus 5.5 with auto mode enabled 2. Route the goal evaluator hook to the new Haiku 5.5 via ANTHROPIC_DEFAULT_HAIKU_MODEL 3. Use Sonnet 5.5 for implementation and refactoring turns, keeping fixes isolated 4. Add one rule to CLAUDE.md: always bound autonomous /goal conditions with a verifiable end state and stop after 20 turns with no progress 5. Route fast deterministic forks through JEV Show me every change as a diff first, no edits until I say go" ↳ save it, it'll come in handy

THIS IS PURE F*CKING GOLD Anthropic just dropped the ultimate autonomy loop for Claude Code The idea: run /goal in auto mode, and let the new Haiku 5.5 judge every turn True overnight autonomy with zero burn: Sonnet builds, Haiku evaluates at 340 tok/s, Opus signs off You just launch Claude Code like this: claude --model opus --dangerously-skip-permissions here's the split: → Opus 5.5 locks the goal condition and plans the overall architecture → Sonnet 5.5 writes the fixes, refactors modules, and runs test suites → Haiku 5.5 evaluates completion after every turn as an independent Stop hook → you stop burning Opus context on dozens of intermediate iteration turns Opus only shows up at three moments: → framing the goal condition before the loop starts → intervening if the loop hits the turn cap or an impossible verdict → signing off on the final git diff once the goal clears Opus frames · Sonnet builds · Haiku judges JEV engineering is the same move one layer down: the forks that need no thinker (which tool, path resolution, retry or abort) clear in milliseconds, and the big models only see the ones that split the full tree > Opus 5.5 runs the main session and defines the completion condition > auto mode approves safe tool calls so turns run unattended > Sonnet 5.5 patches code and runs test suites in an isolated copy > Haiku 5.5 evaluates transcript evidence: Met · Not yet met · Impossible > background check-in monitors idle tasks and backs off stuck loops > Opus 5.5 reviews the achieved transcript and signs off on the diff > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Run the main session on Opus 5.5 with auto mode enabled 2. Route the goal evaluator hook to the new Haiku 5.5 via ANTHROPIC_DEFAULT_HAIKU_MODEL 3. Use Sonnet 5.5 for implementation and refactoring turns, keeping fixes isolated 4. Add one rule to CLAUDE.md: always bound autonomous /goal conditions with a verifiable end state and stop after 20 turns with no progress 5. Route fast deterministic forks through JEV Show me every change as a diff first, no edits until I say go" ↳ save it, it'll come in handy

mirku

25,309 views • 16 days ago

THIS IS A PURE F*CKING GOLDMINE Anthropic just shared one of the best tricks for Claude Code. The idea: let Opus 5.5 write the plan as a script, and let 12 cheap agents run it while Opus sits idle at zero tokens. Same task, two ways: Opus solo was 49% done and still running. The swarm finished in 9 minutes on 165k tokens. You just launch Claude Code like this: claude --model opus --swarm haiku,sonnet here's the split: → Opus 5.5 writes plan.js, then stops reading anything → 6 Haiku 5.5 agents audit every file in parallel → 4 Sonnet 5.5 agents patch each fix in its own isolated copy → 2 Haiku 5.5 agents cross-check, 8 of 9 findings survive Opus only shows up at two moments: → writing the plan before the run → signing off on the verified fixes after it Opus plans. Haiku scans. Sonnet ships. JEV engineering is the same move one layer down: 3,767 forks this run - which model, which lane, retry or stop - resolved in code, and only the genuinely split ones ever reach Opus the full tree > Opus 5.5 runs the main session on xhigh and writes plan.js > scan audits each file on Haiku 5.5, six in parallel > patch applies each fix on Sonnet 5.5 in its own isolated copy > verify cross-checks every finding on Haiku 5.5 > Opus 5.5 reads only what survived, then signs off > JEV resolves micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: Run the main session on Opus 5.5 with effort xhigh and swarm haiku,sonnet. Have Opus write the plan as a script: scan on Haiku 5.5, patch on Sonnet 5.5 in isolated copies, verify on Haiku 5.5. Let the phases overlap - each finding moves on as soon as its own stage finishes, no waiting for the batch. Never surface raw agent output to the main session, only verified results. Route deterministic forks (model choice, lane choice, retries) through JEV. Show me every change as a diff first. No edits until I say go." ↳ save it, it’ll come in handy

THIS IS A PURE F*CKING GOLDMINE Anthropic just shared one of the best tricks for Claude Code. The idea: let Opus 5.5 write the plan as a script, and let 12 cheap agents run it while Opus sits idle at zero tokens. Same task, two ways: Opus solo was 49% done and still running. The swarm finished in 9 minutes on 165k tokens. You just launch Claude Code like this: claude --model opus --swarm haiku,sonnet here's the split: → Opus 5.5 writes plan.js, then stops reading anything → 6 Haiku 5.5 agents audit every file in parallel → 4 Sonnet 5.5 agents patch each fix in its own isolated copy → 2 Haiku 5.5 agents cross-check, 8 of 9 findings survive Opus only shows up at two moments: → writing the plan before the run → signing off on the verified fixes after it Opus plans. Haiku scans. Sonnet ships. JEV engineering is the same move one layer down: 3,767 forks this run - which model, which lane, retry or stop - resolved in code, and only the genuinely split ones ever reach Opus the full tree > Opus 5.5 runs the main session on xhigh and writes plan.js > scan audits each file on Haiku 5.5, six in parallel > patch applies each fix on Sonnet 5.5 in its own isolated copy > verify cross-checks every finding on Haiku 5.5 > Opus 5.5 reads only what survived, then signs off > JEV resolves micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: Run the main session on Opus 5.5 with effort xhigh and swarm haiku,sonnet. Have Opus write the plan as a script: scan on Haiku 5.5, patch on Sonnet 5.5 in isolated copies, verify on Haiku 5.5. Let the phases overlap - each finding moves on as soon as its own stage finishes, no waiting for the batch. Never surface raw agent output to the main session, only verified results. Route deterministic forks (model choice, lane choice, retries) through JEV. Show me every change as a diff first. No edits until I say go." ↳ save it, it’ll come in handy

Sprytix

19,842 views • 16 days ago

Anthropic engineer: "You don't need better prompts. You need to master Opus 5.5 engineering: so your agent never forgets anything." In 1 hour he explains what Anthropic does differently, how to build and structure work with agents. This beats any paid agent course I've seen. Watch it, then save the exact Claude Code Opus 5.5 setup guide below 👇

Anthropic engineer: "You don't need better prompts. You need to master Opus 5.5 engineering: so your agent never forgets anything." In 1 hour he explains what Anthropic does differently, how to build and structure work with agents. This beats any paid agent course I've seen. Watch it, then save the exact Claude Code Opus 5.5 setup guide below 👇

darkzodchi

57,070 views • 1 month ago

THIS IS A PURE F*CKING DIAMOND Anthropic just documented one of the best setups for Claude Code The idea: run Opus 5.5, Sonnet 5.5, and the new Haiku 5.5 together in a tight tripartite loop, each doing only what it was built for Opus-level planning on every big architectural decision, without paying Opus rates for routine code edits or repo searches You just start Claude Code like this: CLAUDE_CODE_SUBAGENT_MODEL=haiku claude --model opusplan here's how it splits: → Opus 5.5 runs plan mode: architects the system blueprint, locks contracts, and signs off on the diff → Sonnet 5.5 executes the plan in the main session: writes the code, applies patches, and runs test suites → Haiku 5.5 swarms the repository in parallel: maps the AST, greps call sites, and parses docs at 340 tok/s with native 1M context → you stop burning Opus context on routine files and keep your main session under 10k tokens Opus only steps in at three moments: → before a plan locks (architectural design) → when the same test fails twice (debugging deadlocks) → before calling it done (signing off on git diff) Opus plans, Sonnet builds, Haiku swarms JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) resolve in code in 15ms, and the frontier models only see the ones that split the full tree > Opus 5.5 architects the implementation plan (opusplan mode) > Sonnet 5.5 runs the main execution session and writes code > search maps the repo AST on Haiku 5.5 (340 tok/s, 1M context) > grep locates token call sites on Haiku 5.5 (isolated subagent) > docs pulls API specifications on Haiku 5.5 (0.05x cost) > Opus 5.5 verifies synthesized diff before final sign-off > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Reconfigure my Claude Code setup around this tree: 1. Run with model 'opusplan' so Opus 5.5 plans the architecture and Sonnet 5.5 implements the code 2. Set CLAUDE_CODE_SUBAGENT_MODEL=haiku so all search, grep, and documentation subagents swarm on Haiku 5.5 with its native 1M context 3. Configure fallbackModel to ['sonnet', 'haiku'] in settings.json to guarantee 100% session availability 4. Add one rule to CLAUDE.md: delegate all repository searches and test runs to Haiku 5.5 subagents to keep main context under 10k tokens 5. Route fast deterministic forks (tool choice, path selection, retries) through JEV Show me every change as a diff first. No edits until I say go" ↳ save it, it'll come in handy

THIS IS A PURE F*CKING DIAMOND Anthropic just documented one of the best setups for Claude Code The idea: run Opus 5.5, Sonnet 5.5, and the new Haiku 5.5 together in a tight tripartite loop, each doing only what it was built for Opus-level planning on every big architectural decision, without paying Opus rates for routine code edits or repo searches You just start Claude Code like this: CLAUDE_CODE_SUBAGENT_MODEL=haiku claude --model opusplan here's how it splits: → Opus 5.5 runs plan mode: architects the system blueprint, locks contracts, and signs off on the diff → Sonnet 5.5 executes the plan in the main session: writes the code, applies patches, and runs test suites → Haiku 5.5 swarms the repository in parallel: maps the AST, greps call sites, and parses docs at 340 tok/s with native 1M context → you stop burning Opus context on routine files and keep your main session under 10k tokens Opus only steps in at three moments: → before a plan locks (architectural design) → when the same test fails twice (debugging deadlocks) → before calling it done (signing off on git diff) Opus plans, Sonnet builds, Haiku swarms JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) resolve in code in 15ms, and the frontier models only see the ones that split the full tree > Opus 5.5 architects the implementation plan (opusplan mode) > Sonnet 5.5 runs the main execution session and writes code > search maps the repo AST on Haiku 5.5 (340 tok/s, 1M context) > grep locates token call sites on Haiku 5.5 (isolated subagent) > docs pulls API specifications on Haiku 5.5 (0.05x cost) > Opus 5.5 verifies synthesized diff before final sign-off > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Reconfigure my Claude Code setup around this tree: 1. Run with model 'opusplan' so Opus 5.5 plans the architecture and Sonnet 5.5 implements the code 2. Set CLAUDE_CODE_SUBAGENT_MODEL=haiku so all search, grep, and documentation subagents swarm on Haiku 5.5 with its native 1M context 3. Configure fallbackModel to ['sonnet', 'haiku'] in settings.json to guarantee 100% session availability 4. Add one rule to CLAUDE.md: delegate all repository searches and test runs to Haiku 5.5 subagents to keep main context under 10k tokens 5. Route fast deterministic forks (tool choice, path selection, retries) through JEV Show me every change as a diff first. No edits until I say go" ↳ save it, it'll come in handy

mirku

38,620 views • 14 days ago

THIS IS A PURE F*CKING CODING JACKPOT Anthropic built the most powerful Claude Code feature and hid it from us Claude Code can now run a whole team of AI agents from one script, and almost nobody has switched it on here's the idea: Opus 5.5 writes the plan as a script, cheap fast models do the grunt work in parallel, and Opus only reads the final result the script holds the loop. not Opus. so your expensive model isn't burning context on a hundred agent chats you turn it on like this: claude --model opus --effort ultracode here's how I'd split the work: -> Opus 5.5 turns your goal into a workflow script -> Haiku 5.5, the fastest Claude model right now, scans every file in parallel -> Sonnet 5.5 makes each fix in its own isolated copy of the repo, so edits don't collide -> separate checker agents try to knock down every finding before you see it Opus only shows up three times: -> writing the script before the run -> reading what survived the checks -> your final yes before anything goes to git Opus plans. Haiku scans. Sonnet fixes. and here's my twist: Jev is the same idea one level down. the tiny forks that don't need a thinker (which file, which tool, retry or stop) go to Jev in milliseconds, and the big models only get the hard ones paste this into Claude Code: "Rebuild my Claude Code setup around this: 1. Run the main session on Opus 5.5 with ultracode on 2. In every workflow, run read-only scan stages on claude-haiku-5-5 and edit stages on claude-sonnet-5-5, each edit in its own isolated copy 3. Add one rule to CLAUDE.md: every finding gets an independent checker agent before it's reported, and fix loops stop after two rounds with no progress 4. Send fast simple decisions (tool choice, path selection, retries) through Jev Show me every change as a diff first. No edits until I say go." the catch: ultracode spends a lot more tokens per request. great for big sweeps, overkill for a one-line fix ↳ save it, you'll need it

THIS IS A PURE F*CKING CODING JACKPOT Anthropic built the most powerful Claude Code feature and hid it from us Claude Code can now run a whole team of AI agents from one script, and almost nobody has switched it on here's the idea: Opus 5.5 writes the plan as a script, cheap fast models do the grunt work in parallel, and Opus only reads the final result the script holds the loop. not Opus. so your expensive model isn't burning context on a hundred agent chats you turn it on like this: claude --model opus --effort ultracode here's how I'd split the work: -> Opus 5.5 turns your goal into a workflow script -> Haiku 5.5, the fastest Claude model right now, scans every file in parallel -> Sonnet 5.5 makes each fix in its own isolated copy of the repo, so edits don't collide -> separate checker agents try to knock down every finding before you see it Opus only shows up three times: -> writing the script before the run -> reading what survived the checks -> your final yes before anything goes to git Opus plans. Haiku scans. Sonnet fixes. and here's my twist: Jev is the same idea one level down. the tiny forks that don't need a thinker (which file, which tool, retry or stop) go to Jev in milliseconds, and the big models only get the hard ones paste this into Claude Code: "Rebuild my Claude Code setup around this: 1. Run the main session on Opus 5.5 with ultracode on 2. In every workflow, run read-only scan stages on claude-haiku-5-5 and edit stages on claude-sonnet-5-5, each edit in its own isolated copy 3. Add one rule to CLAUDE.md: every finding gets an independent checker agent before it's reported, and fix loops stop after two rounds with no progress 4. Send fast simple decisions (tool choice, path selection, retries) through Jev Show me every change as a diff first. No edits until I say go." the catch: ultracode spends a lot more tokens per request. great for big sweeps, overkill for a one-line fix ↳ save it, you'll need it

kiosa

19,390 views • 15 days ago

A viral Claude Code guide claims agent teams cut token use, but Anthropic's documentation says teams use significantly more tokens than a single session. → Agent teams are experimental and turn on with CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1, and each teammate has its own context window → There is no --teammates flag: users ask Claude for teammates in plain language, and custom roles go in subagent definitions → The token saver is the advisor tool, where a cheaper main model consults Opus or Fable only at key decision points → The advisor turns on with /advisor opus, the advisorModel setting or claude --advisor opus Source:

A viral Claude Code guide claims agent teams cut token use, but Anthropic's documentation says teams use significantly more tokens than a single session. → Agent teams are experimental and turn on with CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1, and each teammate has its own context window → There is no --teammates flag: users ask Claude for teammates in plain language, and custom roles go in subagent definitions → The token saver is the advisor tool, where a cheaper main model consults Opus or Fable only at key decision points → The advisor turns on with /advisor opus, the advisorModel setting or claude --advisor opus Source:

0xMarioNawfal

49,119 views • 28 days ago

This guy explained agent harness, memory, and loop engineering in one video - clearer than most paid courses a raw LLM with no harness is a wild horse. all power, no direction > trace the run -> score it with an LLM -> diagnose the bottleneck -> patch it -> ship it that loop is what lets an agent get sharper on its own, run after run memory + harness + loop engineering + evals - that's the whole stack in one picture watch it, then grab the diagram below

This guy explained agent harness, memory, and loop engineering in one video - clearer than most paid courses a raw LLM with no harness is a wild horse. all power, no direction > trace the run -> score it with an LLM -> diagnose the bottleneck -> patch it -> ship it that loop is what lets an agent get sharper on its own, run after run memory + harness + loop engineering + evals - that's the whole stack in one picture watch it, then grab the diagram below

Mr. Buzzoni

45,278 views • 3 months ago