Claude Code Agent Teams, Gemini 4 Argon and the Loops-and-Graphs Playbook

Lately the agent world stopped asking "can one model do it?" and started asking "who's the team lead?". Anthropic opened a public beta of Projects (a coordinator that runs parallel cloud threads) and documents agent teams in Claude Code. Google launched Gemini 4 Argon with a 1M-token output limit. And Hanako's X article on loops and graphs (still doing numbers since August) is the playbook for wiring it together without babysitting. We read the primary sources and drew the diagrams. Every fact is attributed; the opinions and jokes are ours.

TL;DR

• Claude Projects (public beta, Pro and Max): one conversation acts as a coordinator and starts a parallel thread (usually a cloud session) per task, each on its own branch, opening a PR when needed.
• Claude Code agent teams (experimental): a team lead, teammates with their own context, a shared task list and a mailbox. Turn on with CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1.
• Plugins bundle MCP connectors and Agent Skills; a new submission portal is live, and @ClaudeDevs says MCP usage across Claude products is up 110x this year.
• Gemini 4 Argon: output limit 1M tokens (up from 64K), introductory price $2 / $10 per million tokens, rolling out to trusted cyber defenders first. Benchmarks are Google-reported.
• The playbook (@hanakoxbt): a loop makes one unit correct, a graph decides which units exist, gates open on blast radius, and the human approves one step: the merge. 🫡

Claude got a team lead

Anthropic now has three ways to run more than one Claude at once, plus a packaging format for the tools they all share. Here's the verified map, built only from Anthropic's own docs and posts:

Projects: one coordinator, many cloud threads

Anthropic's Projects docs pitch it in one line: "Hand Claude a stream of related tasks in one conversation and let it run them as parallel cloud sessions that share repositories, instructions, and memory." The project conversation is the coordinator. It decides what becomes a thread, tracks every thread, and, per the docs, "sees what threads report back, not every step they take." Each thread is a worker: a separate session with its own context window, one piece of work, a report at the end. Threads usually run as cloud sessions, so they keep going after you close the laptop, and you can steer from your phone. When a task needs your machine, a thread can run locally via Remote Control.

Every cloud thread starts with the project's repos, files, instructions and memory; the CLAUDE.md and skills in each repo; the connectors on your claude.ai account; and a cloud environment with network access, env vars, credentials and tools. It works on its own branch and opens a PR when needed. The Overview pane shows finished threads, PRs ready for review and threads waiting on you, with Library, Pull requests and Routines tabs.

Agent teams: a lead, teammates, a task list, a mailbox

Agent teams live in the Claude Code CLI. They're experimental and off by default; Anthropic's docs enable them with one env var in settings.json (or your shell):

{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  }
}

You spawn a team in plain English. These prompts are verbatim from the docs:

I'm designing a CLI tool that helps developers track TODO comments across their codebase. Spawn three teammates to explore this from different angles: one on UX, one on technical architecture, one playing devil's advocate.

Spawn 5 agent teammates to investigate different hypotheses. Have them talk to each other to try to disprove each other's theories, like a scientific debate.

Teammates load CLAUDE.md, MCP servers and skills, but not the lead's conversation history, so put the context in the spawn prompt. The docs suggest 3–5 teammates with 5–6 tasks each, no two teammates on the same file, and starting with research or review. Our favourite line: "Three focused teammates often outperform five scattered ones." Quality gates come as hooks (TeammateIdle, TaskCreated, TaskCompleted; exit code 2 sends feedback or blocks). Known limits: one team per session, no nested teams, task status can lag, and split panes don't work in the VS Code terminal, Windows Terminal or Ghostty. A teammate also can't approve permissions on your behalf.

Subagents vs agent teams

Plugins: the portal and the 110x

Anthropic's Sep 25 post says "Plugins package MCP connectors, Agent Skills, or both, and are the main way to build third-party extensions for Claude." The new directory submission portal validates and safety-scans uploads, tracks review feedback, publishes, then shows installs by product surface and version, listing views and search queries. It's open to developers on paid Claude plans and supports MCP 2.0, including MCP Apps (interactive UI) and Enterprise Managed Auth. The same day, @ClaudeDevs posted: "MCP usage across Claude products is up 110x this year!" If your agents need tools, this is now the shelf they're stocked from. New to the vocabulary? Our harness engineering explainer covers how tools, skills and hooks wrap the model.

Gemini 4 Argon: 1M tokens of output

On September 30, Koray Kavukcuoglu announced Gemini 4 Argon on the Google blog: a new frontier model with an unusual launch order. Cyber defenders first, everyone else later.

What 1M output actually means

Most model headlines brag about the context window: how much you can feed in. Argon's headline is the other side. Google says its output token limit is 1M, up from 64K, which it calls industry-leading, enough to "generate hundreds of thousands of tokens in a single trajectory". That's the max a single request can write back, separate from how much it can read. By our arithmetic it's roughly 16x more room per response. For agents, that's a whole migration in one run instead of a relay of chunked calls.

The receipts (Google-reported)

Cyber first: the Fairwind rollout

Argon rolls out first to trusted cyber defenders through Google's Fairwind Program, in a phased release; Google says it also engaged in U.S. government voluntary pre-release access. Developers, enterprises and consumers come later, "starting with paid API customers and Google AI Ultra subscribers". Google says the model finds, validates and patches vulnerabilities, and that Wiz's Scan for Good used it to find a critical vulnerability in hospital healthcare software that previous frontier models missed.

Price: $2 in, $10 out

Google lists an introductory price of $2 per million input tokens and $10 per million output tokens, with cached input 95% off the input price (by our math, $0.10 per million). Google's footnote adds that after the introductory period the price becomes $4 per million input and $20 per million output. For context only: Anthropic lists Claude Opus 5.5 at $4 / $20 — the same list price as Argon after its intro period. Those are two vendors' own list prices for different models with different benchmarks, so don't read them as a ranking. Price the tokens your workload actually burns — at 1M output, the output column is the one to watch.

Google's own agents went first

• Quantum algorithm optimisation: beat the published baseline by 40% in minutes, per Google.
• Argon agents freed more than 300 TiB of memory across Google's data centers (Google estimates 500 TiB to 1 PiB in total).
• C/C++ → Rust migrations from tens of thousands of lines (re2, libgav1) up to 800K+ lines (the Fuchsia Zircon kernel), under rigorous auditing.
• libgav1: replaced 32K lines of SIMD code with a memory-safe decoder 2.7x faster than the existing Rust port, with identical output.

The playbook: loops and graphs

More agents and longer outputs mean more ways to go wrong at scale. The best map we've seen this month is Hanako's (@hanakoxbt) X article "Loops and Graphs: how to stop babysitting agents and only approve the last step" (Aug 23, around 8M views). Its thesis in one line: "A loop makes a unit of work correct without you. A graph decides which units exist at all." If that sounds like our graph engineering explainer, it is: this is the short field version, and the explainer covers node types, edges and loop layers in depth.

A loop is a check that can fail

A loop is produce, check, correct, repeat until green. Hanako's point: "The check is the whole thing." Without a check that can fail, "you have a scheduler". So write the check first, and make it programmatic.

The graph layer: splitter, workers, code node, gate

A loop's ceiling, per Hanako: it can't decide which units exist or their order, so you get "a very good agent running the wrong three steps, in the wrong order". A graph fixes that. Nodes are bounded jobs; edges are dependencies where one node's output feeds another's input. There are four node kinds: a splitter cuts by blast radius, not by folder; workers each get their own context; a code node does merge, rank and dedupe ("If you can describe the transformation without using the words judge, decide, assess or summarize, it is code."); and a gate decides what passes.

"The loop lives inside a node. The graph lives between them." A failed unit goes back to its producer on a short correction edge ("Return the unit, not the batch", capped at three attempts), and an accepted result feeds a lesson back into the splitter's brief.

Gate on blast radius, not confidence

Here's the spicy part. Hanako argues confidence is the one gate signal "the model can influence", so don't gate on it. Gate on how much breaks if the step is wrong:

Put the human on one step

Where do you go? On the single step with the highest consequence and the lowest reversibility: approve the merge, not the intermediate output. In Hanako's words, "A human in the middle of a graph becomes the slowest node in it."

Plot twist: Jev as the reranker

Remember Jev, the System One model that answers in types? On September 24, Erik Kaunismäki (@ErikKaum) posted that turbopuffer had tested it as a search reranker. The run (by William, @n0riskn0r3ward) compared Jev with Voyage rerank-3, Jina reranker-v3.5 and GPT 5.6 Luna (low), using GPT 5.6 Sol (no reasoning) as the relevance baseline. Jev's Score API rated each document on ten relevance levels, from "unrelated" to "perfect match", and the probabilities became a weighted relevance score.

Where does that fit the playbook? A reranker is a code-node-shaped job: rank and dedupe, with a model supplying the scores. Our take: use Jev's scores to rank and route inside reversible lanes, and don't let any confidence number open a hard-to-reverse lane. Hanako's blast-radius rule still wins there. And if price matters more than agreement, Voyage was cheaper in the same test.

Putting it together

Here's the whole thing as one picture: an agent team where the lead plays splitter, teammates are workers with their own loops, a deterministic gate checks the merge, and you approve one step. It's our sketch, not a product diagram. Pair it with a sensible effort level per teammate.

TL;DR of the TL;DR: the models got bigger outputs and the tools got team leads, but the leverage is still in the checks. Write the check first, gate on blast radius, approve the merge. No babysitting. 🫡