AgentFleet: Inside the 19-Lane Provider-Agnostic Subagent Architecture for Claude Code

When running autonomous coding workflows in production, single-agent setups quickly run into structural bottlenecks: planning queries pollute the context window with file diffs, test exploration burns expensive reasoning tokens, and giving every subagent unrestricted write access creates silent regressions.

Today, Sync Studios officially open-sourced AgentFleet (agentfleet.wecansync.com / github.com/wecansync/claude-agents-config), a bootstrap installer and orchestration layer designed to turn Claude Code into a battle-tested, 19-lane agent fleet.

Here is an architectural deconstruction of why AgentFleet was built, how its least-privilege lane isolation works, and what it solves for engineering teams running autonomous coding agents at scale.

1. The Core Philosophy: Specialization Over Generalization

Most developers use coding agents as general-purpose chatbots with shell access. This creates three fatal engineering issues:

Context Contamination: A single long-running session that researches codebases, writes tests, implements features, and reviews diffs exhausts its attention budget within minutes.
Privilege Overreach: An exploratory research agent should never have Bash, Edit, or Write capabilities. Giving write tools to an exploration query invites unintended side effects.
Vendor Lock-In: Default setups bind developers to a single subscription tier, preventing hybrid routing through internal enterprise gateways, local LLMs, or high-throughput proxies.

AgentFleet addresses this by provisioning 19 discrete lanes directly under ~/.claude/agents/fleet-*.md.

2. The 19-Lane Breakdown & Least-Privilege Isolation

AgentFleet organizes work across two distinct tiers: Task Lanes (functional responsibilities) and Variant Lanes (capability-based routing).

Functional Task Lanes (12 Lanes)

fleet-plan: Architectural design, RFC breakdown, and requirements decomposition (Read-Only — no Bash, Edit, or Write).
fleet-implement: Core feature construction and refactoring (Writable).
fleet-review: Adversarial code review of branches and diffs (Read-Only).
fleet-tests: Test suite generation, test repair, and failure investigation (Writable).
fleet-ui: Frontend component crafting and design-system alignment (Writable).
fleet-docs: Technical documentation, architecture decision records (ADRs), and changelogs (Writable).
fleet-security-review: Dedicated audit lane for authentication, secrets, SQL injection, and trust boundaries (Read-Only).
fleet-diagnose-static: Root-cause failure analysis directly from source code (Read-Only).
fleet-explore-narrow: Bounded symbol, file, and call-site lookup (Read-Only).
fleet-triage-static: Issue triage and task scoping (Read-Only).
fleet-research-codebase: Repository-wide sweep and system explanation (Read-Only, zero web access).
fleet-research-web: Live documentation and external library discovery via WebSearch and WebFetch (Read-Only).

Capability Variant Lanes (7 Lanes)

Variants are named for an operational capability rather than a vendor model name, ensuring prompts remain stable across provider shifts:

fleet-plan-alt & fleet-implement-alt: Independent second opinions evaluated on isolated alternative models to prevent blind spots.
fleet-implement-fast: Low-latency, sub-second execution for simple file edits and syntax fixes.
fleet-implement-deep: High-compute reasoning for multi-file architectural refactors.
fleet-implement-cheap: High-volume background sweeps on budget or free model tiers.
fleet-review-alt & fleet-review-deep: Independent code review and deep scrutiny for migrations, concurrency, and data-loss risks.

All subagents operate as background workers with omitClaudeMd: true and cannot spawn nested agents, commit, push, or execute external deployment actions. The main session retains ultimate gatekeeping authority.

3. Dynamic Gateway Reconciliation & Zero Lock-In

One of AgentFleet’s most powerful architectural features is Provider Independence. On initial setup, developers choose how Claude Code connects:

Claude Subscription: Standard native access mapping lanes to opus, sonnet, and haiku.
Anthropic API Key: Direct API billing via ANTHROPIC_API_KEY.
Custom Gateways: Any Anthropic-compatible reverse proxy (such as Omniroute, LiteLLM, or OpenRouter).

When connected to a gateway, AgentFleet’s startup hook automatically queries GET /v1/models, discovers active endpoints, inspects context windows, and assigns models into capability tiers:

[Discovered Models via GET /v1/models]
                   │
                   ▼
┌────────────────────────────────────────────────────────┐
│             Capability Tier Classifier                 │
│  • cheap:    free/open-source endpoints                │
│  • fast:     flash/mini/sub-100ms streaming            │
│  • balanced: standard frontier models (Sonnet class)   │
│  • deep:     heavy reasoning models (Opus / Sol class) │
└────────────────────────────────────────────────────────┘
                   │
                   ▼
┌────────────────────────────────────────────────────────┐
│             Startup Fleet Reconciler                   │
│  • Ranks models by tier fit, reasoning, & 1M context   │
│  • Assigns best match + up to 3 automatic fallbacks    │
│  • Guarantees sibling '-alt' lanes never share weights │
└────────────────────────────────────────────────────────┘

You can switch profiles instantaneously without reinstalling:

agentfleet use native        # Switch to Claude subscription
agentfleet use enterprise    # Switch to internal corporate gateway

4. Intelligent Context Compaction & Privacy Safeguards

Long agent sessions frequently crash due to unmanaged context accumulation. AgentFleet installs a dedicated context-budget hook (sync-model-context.py):

At SessionStart and PostModelSwitch, it queries the active model’s true context limit.
Automatically applies a 90% headroom ceiling to CLAUDE_CODE_MAX_CONTEXT_TOKENS and synchronizes autoCompactWindow.
Prevents context truncation errors while ensuring the agent never exhausts its working memory mid-task.

Privacy-Preserving Routing

The routing engine (route-to-fleet.py) operates strictly under user permissions:

Logs are restricted to mode 0600 in the user’s home directory.
Logs track lane assignments, execution timestamps, and character counts—never full prompt text.
All credential-shaped patterns (tokens, keys, secrets) are redacted in flight.

5. Getting Started

AgentFleet installs with a single non-root command on macOS, Linux, and Windows PowerShell:

# macOS / Linux
curl -fsSL https://agentfleet.wecansync.com/install.sh | sh

# Windows PowerShell
irm https://agentfleet.wecansync.com/install.ps1 | iex

The installer verifies SHA-256 release checksums, creates an automatic backup snapshot of existing configurations under ~/.claude/backups/, and supports non-destructive rollbacks via agentfleet rollback --apply.

To explore the architecture, inspect the codebase, or contribute, visit the official repository:

Installer & Documentation: agentfleet.wecansync.com
GitHub Repository: github.com/wecansync/claude-agents-config

Sources & Architecture References: Sync Studios Engineering, AgentFleet 2.0.2 Specification, Anthropic Claude Code Agent Documentation.