Industry Comparison: Coding Agents

A technical comparison of major coding agents as of January 2026.

Quick Comparison

Agent	Type	Interface	Open Source	Model	Price
Claude Code	Autonomous	CLI	No	Claude	$20/mo (Pro)
Cursor	Copilot	IDE	No	Multi	$20/mo (Pro)
GitHub Copilot	Copilot	IDE Extension	No	GPT-4/5	$10-19/mo
Amp Code	Autonomous	CLI + IDE	No	Multi	Enterprise
Codex	Autonomous	API/CLI	No	GPT-5.2	API pricing
Factory Droids	Task agents	Embedded	No	Multi	Enterprise
Aider	Autonomous	CLI	Yes (Apache)	Multi	Free + API
Cline	Autonomous	VS Code	Yes (Apache)	Multi	Free + API

Architecture Comparison

Claude Code (Anthropic)

Architecture:

User → CLI → Agent Loop → Claude API
              ↓
         Tool Execution (Read/Edit/Bash)
              ↓
         Streaming Response

Key patterns:

Single-agent with tool use loop
Course correction via meta-agent (Gemini monitors Claude)
AGENTS.md for project-specific memory
Subagents for specialized tasks (finder, oracle, etc.)

Context management:

Extended context (1M tokens)
Handoff system for long conversations
LLM-driven context extraction

Unique: Course correction system catches "hallucinated success"

Amp Code (Sourcegraph)

Architecture:

User → CLI/IDE → ThreadWorker → Multi-Model Router
                      ↓
              Tool Execution (44+ tools)
                      ↓
              Subagent Delegation

Key patterns:

Multi-model orchestration (Claude, GPT-5, Gemini)
11 subagent types with complete isolation
Thread-based persistence with fork/handoff
Skills system for extensibility

Context management:

1M token context
LLM-driven handoff extraction
Token budgets per file (50K limit)

Unique: Multi-model routing (GPT-5.2 for Oracle, Gemini for course correction)

Cursor

Architecture:

User → IDE → Codebase Index → Agent/Composer
                  ↓
         Multi-file Planning
                  ↓
         Inline Edits

Key patterns:

IDE-native with deep VS Code integration
Codebase-wide indexing for context
Composer mode for multi-file changes
Inline diff application

Context management:

Automatic codebase indexing
Semantic search for relevant context
Smart file inclusion

Unique: IDE-first experience with visual diffs

Aider

Architecture:

User → CLI → Repository Map → LLM
                  ↓
         Git-aware Edits
                  ↓
         Auto-commit

Key patterns:

Repository map (function signatures, structure)
Git-native with automatic commits
Three modes (Code, Architect, Ask)
BYOK model flexibility

Context management:

Repo map gives LLM codebase overview
Selective file loading
Conversation history in git

Unique: Git as first-class citizen - every change is a commit

Cline

Architecture:

User → VS Code → MCP Tools → LLM
                    ↓
         Human Approval Loop
                    ↓
         File/Terminal Actions

Key patterns:

MCP (Model Context Protocol) for tool extensibility
Human-in-the-loop for every action
AST-based context analysis
Memory Bank for project knowledge

Context management:

Dynamic context management
AST analysis for precise code extraction
Memory Bank for tribal knowledge

Unique: MCP integration as "app store for AI capabilities"

Factory Droids

Architecture:

User → Task Definition → Droid Selection
                              ↓
                     Specialized Execution
                              ↓
                     CI/CD Integration

Key patterns:

Task-specific agents (not general-purpose)
Deep CI/CD integration (GitHub, Jira, etc.)
Specialized Droids for different tasks
Embedded in developer workflow

Context management:

Task-scoped context
Integration with external tools for context
Workflow-aware

Unique: Purpose-built agents vs general-purpose

Feature Comparison

Tool Capabilities

Capability	Claude Code	Amp	Cursor	Aider	Cline
Read files	✅	✅	✅	✅	✅
Edit files	✅	✅	✅	✅	✅
Create files	✅	✅	✅	✅	✅
Run shell	✅	✅	Limited	✅	✅
Git operations	✅	✅	✅	✅ Native	✅
Web search	✅	✅	✅	❌	Via MCP
Browser control	❌	✅	❌	❌	✅
Multi-file refactor	✅	✅ (Kraken)	✅ (Composer)	✅	✅

Context Features

Feature	Claude Code	Amp	Cursor	Aider	Cline
Context window	1M	1M	128K+	Model-dependent	Model-dependent
Codebase indexing	Manual	Manual	Automatic	Repo map	AST-based
Project memory	CLAUDE.md	AGENTS.md	Rules	Git history	Memory Bank
Context handoff	✅	✅	❌	❌	❌

Agent Features

Feature	Claude Code	Amp	Cursor	Aider	Cline
Subagents	✅	✅ (11 types)	❌	❌	❌
Multi-model	Limited	✅ (Claude/GPT/Gemini)	✅	✅	✅
Course correction	✅	✅	❌	❌	❌
Human approval	Per-action	Per-action	Inline	Per-action	Per-action
Autonomous mode	✅	✅	Limited	✅	✅

Design Philosophy Comparison

Anthropic (Claude Code)

"A staff engineer living in your CLI"

Terminal-first, autonomous execution
Trust the agent, review the output
Simple, focused tool set
Single-model, single-agent (with internal subagents)

Sourcegraph (Amp Code)

"Agent-native development"

Multi-model orchestration
Subagent specialization
Thread persistence and sharing
Course correction for reliability

Cursor

"AI should enhance your existing workflow"

IDE-native, visual experience
Human maintains control
Codebase-aware suggestions
Incremental assistance

Aider

"Git-native AI pair programming"

Git as the source of truth
Every change is a commit
Transparent, reversible
BYOK flexibility

Cline

"Open source and uncompromised"

Human-in-the-loop always
MCP for extensibility
Model agnostic
Transparent operation

Common Patterns Across All

Despite different approaches, all production agents share:

1. Tool Use Loop

All implement some form of:

while not done:
    think → act → observe → think

2. File Operations Core

Every agent has tools for:

Reading files
Editing files (usually diff-based)
Creating files
Searching codebases

3. Context Boundaries

All struggle with the same problem:

Context windows are finite
Codebases are large
Must decide what to include

4. Human Checkpoints

Even "autonomous" agents have approval gates:

Claude Code: per dangerous action
Amp: per tool execution
Cline: per every action

5. Project Memory

All have some form of:

CLAUDE.md / AGENTS.md / Memory Bank
Project-specific rules and preferences
Persistent across sessions

Lessons for Building Your Own

From studying these agents:

Do

Start with a simple tool use loop
Build file operations first (Read, edit_file, create_file)
Add context management early
Implement project memory (AGENTS.md pattern)
Have human checkpoints for safety

Don't

Over-engineer subagent systems initially
Ignore context limits
Skip the "project memory" pattern
Assume autonomous = no oversight

Differentiators to Consider

Terminal vs IDE: Who is your user?
Single vs multi-model: Complexity vs flexibility
General vs specialized: One agent or many Droids?
Closed vs open: Control vs community

What We Learned from Amp Code

Our excavation of Amp Code revealed patterns not visible from the outside:

Discovery	Insight
Course correction	Agents need external validation - they don't know they're wrong
Subagent isolation	Complete isolation is safer than context inheritance
LLM-driven handoff	Context decisions are too complex to hardcode
Multi-model routing	Different tasks need different models
Token budgets	Hard limits prevent context overflow

These patterns likely exist in other production agents too - they're solutions to universal problems.

Comparison compiled: January 2026 Based on public documentation, research, and Amp Code excavation