Deep Research — March 31, 2026 | Focus: Simple, focused agent patterns (2–5 agents)
From Anthropic's "Building Effective Agents" guide — five foundational patterns, plus a multi-agent composition pattern.
Sequential task execution — output of step N feeds into step N+1.
When: Clear linear dependencies (analyze → summarize → format)
Agents: 1 (single agent, multiple steps)
Initial classifier directs requests to specialized handlers.
When: Different task types need different expertise (support triage)
Agents: 1 router + N specialists
Multiple independent tasks executed simultaneously, results merged.
When: Tasks don't depend on each other
Agents: N parallel workers
Central orchestrator (Opus) breaks tasks down, delegates to workers (Sonnet) in parallel, synthesizes results.
When: Complex research/analysis requiring decomposition and synthesis
Agents: 1 orchestrator + N workers
Cookbook: orchestrator_workers.ipynb
Generator produces output → Evaluator scores quality → Generator refines. Iterative loop.
When: Quality refinement through feedback loops
Agents: 2 (generator + evaluator)
PM/Planner specs the task → Developer/Generator builds → QA reviews from scratch → PM finalizes.
When: Software development workflows needing multiple perspectives
Agents: 3 (planner + generator + reviewer)
Christopher Kahler built a modular agent ecosystem for Claude Code that emphasizes focused, single-purpose agents with clear separation of concerns.
Initial project scaffolding and discovery. Generates project structure, identifies dependencies, establishes baseline context.
Output: Project skeleton with organized file hierarchy
Core development cycle orchestration. Plans steps → applies changes → unifies results across modules. Three-phase iterative loop.
Output: Coherent, integrated changes across codebase
Dynamic context management. Augments agent context with domain-specific rules via just-in-time rule injection.
Output: Enriched context for smarter agent decisions
Type-aware exploration using probabilistic reasoning. Guides agent decisions through Bayesian inference across solution spaces.
Output: Ranked exploration paths with confidence scores
Sorted by relevance to simple, focused agent patterns (2–5 agents). Star counts approximate as of March 2026.
| Framework | Type | Stars | Agent Pattern | # Agents | Claude Support | Status | Key Differentiator |
|---|---|---|---|---|---|---|---|
| Claude Code Built-in Agent tool |
SDK | Native | Orchestrator-Workers, sub-agents with model selection | 1–5 | ✅ Native | Active | Built into Claude Code itself. Spawn sub-agents with different models, isolated worktrees. Zero setup. |
| Claude Agent SDK Python & TypeScript |
SDK | Official | All 5 Anthropic patterns, composable | 1–N | ✅ Native | Active | Official SDK for building custom agent systems. Programmatic orchestration with tool_use. |
| Aider paul-gauthier |
OSS | ~27k | Architect + Editor (2-model pattern) | 2 | ✅ Claude native | Active | Architect mode: strong model plans, weaker model edits. Git-aware. Pair programming in terminal. |
| OpenHands (ex-OpenDevin) |
OSS | ~46k | Event-driven orchestration + sandboxed execution | 3–8 | ✅ Claude support | Active | Docker sandbox, event stream arch, web UI. Most production-grade OSS agent. |
| Cline VS Code extension |
OSS | ~25k | Developer agent + human-in-the-loop QA | 1–2 | ✅ Claude native | Active | VS Code native. Screenshot + DOM understanding. Permission modes (ask/auto). |
| Roo Code Cline fork |
OSS | ~8k | Multi-mode agents (Code, Architect, Ask, Debug) | 2–4 modes | ✅ Claude support | Active | Cline fork with custom agent modes. Each mode = different system prompt + tool access. |
| SWE-agent Princeton NLP |
OSS | ~15k | Research → Code pipeline with tool agents | 2–5 | ✅ Via LLM bridge | Active | SWE-bench optimized. Browser, file editor, bash tools. Academic-grade agent design. |
| Plandex plandex-ai |
OSS | ~11k | Planner + Builder (plan → execute in sandbox) | 2 | ✅ Claude support | Active | Terminal-native. Plan-first approach. Protected sandbox. Diff review before applying. |
| Devika stitionai |
OSS | ~18k | Research → Hypothesis → Implementation | 3–5 | ✅ Claude support | Active | Web research phase → planning → code generation. "Open-source Devin." |
| Mentat AbanteAI |
OSS | ~3k | Developer + assistant (context-aware) | 1–2 | ✅ Claude API | Active | Terminal-native. Good codebase understanding. Git integration. |
| Devon entropy-research |
OSS | ~3k | Orchestrator + tool agents | 2–3 | ✅ Claude | Active | Shell-based. Subprocess execution. Open-source Devin alternative. |
| Continue.dev continuedev |
OSS | ~22k | IDE-integrated agent with custom commands | 1–2 | ✅ Claude native | Active | VS Code + JetBrains. Open-source Copilot alternative. Custom slash commands. |
| Devin Cognition |
Commercial | N/A | Fully autonomous agent (plan → code → test → deploy) | Internal multi-agent | Own model | Active | First "AI software engineer." Full IDE + browser + terminal. $500/mo. |
| Cursor Anysphere |
Commercial | N/A | Agent mode (plan → edit → verify) | Built-in | ✅ Claude | Active | Most adopted AI code editor. Agent mode with multi-file editing. Composer feature. |
| Windsurf Codeium |
Commercial | N/A | Cascade flow (plan → code → review) | Built-in | ✅ Claude | Active | "Cascade" agentic flow. Context-aware across codebase. Free tier. |
| Codex OpenAI (May 2025) |
Commercial | N/A | Cloud agent (sandbox → PR) | Internal | ❌ OpenAI only | Active | OpenAI's answer to Claude Code. Cloud sandbox. Creates PRs directly. |
| Jules |
Commercial | N/A | Async agent (issue → PR) | Internal | ❌ Gemini only | Active | Google's async coding agent. GitHub integration. Gemini-powered. |
Aider's architect mode is the closest battle-tested implementation of the orchestrator-workers pattern in a coding tool. It uses a two-model setup:
This is exactly your Pattern A: strong model thinks, cheaper model executes. Git-aware, so every change is a commit. Works in terminal — no IDE dependency.
Why it matters: 27k+ stars, battle-tested by thousands of developers daily. Paul Gauthier (creator) has benchmarked it extensively on SWE-bench.
The most feature-complete open-source agent framework. Event-driven architecture means agents communicate via an event stream, enabling complex orchestration patterns.
Key features: Docker sandboxing (each agent gets isolated container), web UI for monitoring, supports all major LLMs, plugin system for custom tools.
Limitation: Can be heavyweight — more agents than you might want. Best for teams that need production-grade safety rails.
Terminal-native tool that enforces a plan-first approach. Creates a protected sandbox, generates a plan, lets you review diffs before applying.
Simple, focused, 2-agent pattern. Good for when you want control over what gets applied.
Cline fork that implements multiple agent "modes" — each mode has a different system prompt and tool access. Think of it as preconfigured agent personas:
Code mode: Full coding agent with file access. Architect mode: Planning only, no file edits. Ask mode: Q&A about codebase. Debug mode: Focused debugging agent.
You can create custom modes — essentially building your own focused agents within the VS Code environment.
Claude Code already has a native Agent tool that spawns sub-agents. Each sub-agent can have:
• A different model (Opus for orchestration, Sonnet for workers, Haiku for quick tasks)
• Isolated git worktree (agent works on its own copy of the repo)
• Specific tool restrictions
• Custom prompts defining its role
This is the zero-setup way to implement orchestrator-workers: just spawn multiple sub-agents in parallel from your main Claude Code session.
You can define custom agent personas in your project's .claude/agents/ directory as YAML files. Each agent gets:
• Custom system prompt (its role and expertise)
• Restricted tool access (e.g., QA agent can only read files, not edit)
• Model preference (e.g., always use Opus for the architect agent)
• Custom CLAUDE.md context
This lets you build Kahler-style focused agents (SEED, PAUL, CARL, Bayes) directly within Claude Code.
Official:
• Building Effective Agents — Anthropic's foundational guide
• Multi-Agent Research System — Anthropic's own implementation
• anthropic-cookbook/patterns/agents — Jupyter notebooks with implementations
• Claude Agent SDK docs — Python & TypeScript SDKs
Community:
• awesome-claude-code-subagents — 100+ pre-built sub-agent configs
• Claude Code Agent Teams Guide — Addy Osmani's walkthrough
TL;DR: Start with Claude Code's built-in sub-agents + Aider's architect pattern. Add Kahler-style .claude/agents configs for your specific Web3 workflows.
Best option: Claude Code's native Agent tool — you're already using it. Spawn 3–4 Sonnet sub-agents for parallel research, synthesize with Opus in the main thread. Zero additional setup.
Alternative: Aider's architect mode for code-heavy work — Opus plans, Sonnet edits. Battle-tested, git-aware.
For custom pipelines: Claude Agent SDK (Python) gives you programmatic control to build exactly the orchestration pattern you want.
Best option: Build this in Claude Code using .claude/agents:
Alternative: Roo Code's custom modes let you switch between PM/Developer/QA personas within VS Code.
Skip OpenHands unless you need Docker sandboxing — it's powerful but heavy for your use case.
Skip Devin/Codex/Jules — closed commercial products, can't customize agent patterns.
Skip frameworks with 50+ agents — CrewAI, AutoGen, etc. Overkill for focused work.
| Layer | Tool | Why |
|---|---|---|
| Orchestration | Claude Code (built-in Agent tool) | Already in your workflow. Sub-agents, model selection, worktree isolation. |
| Pair Programming | Aider (architect mode) | Opus plans + Sonnet edits. Git-aware. Terminal-native. |
| Custom Agents | .claude/agents/ YAML configs | Define PM, Developer, QA, Research personas per project. |
| Custom Pipelines | Claude Agent SDK (Python) | When you need programmatic control beyond what Claude Code provides. |
| IDE Integration | Roo Code (if VS Code) or Continue.dev | Multi-mode agents inside your editor. |