Agent Teams: How AI Agents Are Evolving Organizations

We are in the agentic age of organizational growth.

Last year, Microsoft published the Work Trend Index Annual Report, defining ‘hybrid’ teams of humans and agents. I read it and moved on — until I started reflecting on the progress of multi-agent systems like Claude Code and OpenClaw.

Then, on February 5th, Anthropic shipped agent teams in research preview:

Claude Code now supports agent teams (in research preview)

Instead of a single agent working through a task sequentially, a lead agent can delegate to multiple teammates that work in parallel to research, debug, and build while coordinating with each other.

Try it out today by… pic.twitter.com/vi7lUJDOTi

— Lydia Hallie ✨ (@lydiahallie) February 5, 2026

According to Anthropic’s agent teams docs:

Coordinate multiple Claude Code instances working together as a team, with shared tasks, inter-agent messaging, and centralized management.

We went from one AI agent at a time to multi-agent systems. The shift is agentic orchestration.

OpenClaw sets up one agent to run for you. To go further, you need an orchestrator. That is where antfarm by Ryan Carson comes in:

If you’re using @openclaw this will be a big unlock.

Antfarm is a batteries-included agent team that operates reliably and deterministically.

Works with OpenClaw using just crons, YAML and SQLite.

It auto-runs Ralph loops after creating atomic user stories.

I open sourced it… https://t.co/g6a1N0jwel

— Ryan Carson (@ryancarson) February 9, 2026

When you spin up your first antfarm, you get six agents:

Now we are getting closer to a real team.

How Antfarm Works

Antfarm combines cron jobs, YAML, and SQLite. The execution step is built around the ‘Ralph Wiggum Loop’ — named after the simpleton character from The Simpsons.

Ralph is an autonomous coding loop. It shares the same workflow as a human developer: consult a task list, implement, run tests, commit, mark complete, log what it learned, pick the next task.

Ralph picks one story and executes it:

export type Story = {
  id: string;
  runId: string;
  storyIndex: number;
  storyId: string;
  title: string;
  description: string;
  acceptanceCriteria: string[];
  status: "pending" | "running" | "done" | "failed";
  output?: string;
  retryCount: number;
  maxRetries: number;
};

https://github.com/snarktank/antfarm/blob/bbd6debda1f6b76ca178db923d2478357d810baf/src/installer/types.ts#L61C1-L73C3

The workflow in practice: a human says ‘I want to build this feature.’ A specialized agent interviews the human for specifics. Another agent turns those notes into a prioritized task list. Coding agents implement the work. Category experts verify it.

Spec-driven development handles the planning layer.

Think of it as humans plus RPG agents:

According to antfarm.cool:

Built on the Ralph loop. Each agent runs in a fresh session with clean context. Memory persists through git history and progress files — the same autonomous loop pattern from Ralph, scaled to multi-agent workflows.

Microsoft recognized early that too many agents creates its own problem:

High-Level Architecture

Agent Lifecycle (Ralph Loop Model)

Multi-Agent Story Isolation (feature-dev example)

Custom Workflow Definition (YAML to Runtime)

End-to-End Example Run

Instead of one big agent doing everything, antfarm becomes a deterministic assembly line of specialized agents.

Claude Agent Teams, Taught Incrementally

One way to understand Anthropic’s agent teams is to contrast them against subagents:

Step 1: One agent, one thread

Start simple: one agent handles everything in sequence.

Step 2: Add a lead and specialists

The lead delegates. Teammates run in parallel.

Step 3: Share tasks and messages

Agent teams add a shared task list and direct teammate messaging.

Step 4: Run the claim-and-complete loop

Each teammate claims unblocked work, executes, and updates status.

Step 5: Add quality gates and cleanup

Hooks enforce standards before tasks close; the lead shuts down the team.

This is the shift: from one big agent to a coordinated team with explicit roles, shared state, and controlled handoffs.

Step 6: Gate the feature explicitly

Agent teams stay opt-in behind an environment flag.

Step 7: Use local team state files

Coordination runs through local frontmatter state files, not hidden magic.

Step 8: Notify the lead through tmux

Idle teammates report back through a coordinator session.

Step 9: Launch swarm from interactive command

The command gathers constraints first, then writes shared tasks.

The practical model: explicit flag, explicit files, explicit hooks, explicit task generation.