Why build with one LLM when you can deploy a team?
AOa v2 is a zero-dependency local multi-agent blueprint designed for developers. Spawn parallel specialized sub-agents inside isolated git worktrees, select model + effort tiers dynamically per task, log decisions locally to avoid token quota crashes, and run independent developer-verifier QA chains.
Why Traditional LLM Workflows Collapse
Most developer teams route everything through a single massive model or heavy graph. That approach is slow, expensive, and fails at scale in four critical ways.
Mismatched Model & Effort
Using expensive reasoning models for simple file searches or low-context models for architectural refactoring burns budgets and degrades quality. Developers need precise control over which model handles which task, and at what reasoning effort tier.
Monolithic Quota Crashes
Heavy agent frameworks run long-context loops that exhaust token limits or hit API rate limits mid-process, causing catastrophic crashes and loss of active work. Rate limit blocks must be treated as scheduling states, not runtime errors.
Parallel Agent Collisions
Spawning independent agents in a shared folder causes visual overlap and file corruption. Without workspace isolation, multiple agents edit the same files simultaneously, resulting in merge conflicts and broken state.
Self-Confirming Hallucinations
If the agent implementing the task is also responsible for confirming it works, it will repeatedly verify its own bugs. A strict boundary where the coder agent is isolated from the QA tester agent is required to ensure correctness.
Team-of-Teams Flow with Per-Task Gating
AOa v2 splits orchestrator recommendations from execution decisions. Tasks run concurrently in isolated git-worktrees, validated by independent QA agents, and tracked via a canonical decision log.
Strict QA Verification Gate: Worker != Tester
Under the AOa v2 protocol, a task is structurally blocked from transitioning to done inside the repository message bus until a separate, isolated sub-agent pulls the work into its own worktree and registers a verified status check. No developer agent can test its own modifications.
Multi-Model Economic Efficiency
AOa coordinates local developer client subscriptions alongside remote APIs, minimizing metered API costs through hybrid CLI executions.
Flat-Rate CLI Execution
Standard frameworks depend entirely on metered API tokens, charging per call and ballooning budgets during large projects. AOa executes tasks in CLI mode by default, driving official command-line binaries (Claude Code, OpenAI Codex CLI, Antigravity CLI) directly on your workstation.
- Leverages your existing flat-rate consumer developer subscriptions (Claude Pro, Gemini Advanced).
- Drastically cuts token expenditures by running iterations through secure CLI sandboxes.
- Allows deep exploration of large-context workspaces without API charge anxiety.
Hybrid API Fallback
For automated servers or background runner environments where interactive flat-rate CLI access is not possible, agents can be independently reconfigured to API mode inside their configuration TOML files, using token routing.
- Reads token credentials securely from environment variables.
- Customizable per agent inside
config/agents/TOML structures. - Compatible with local LLM gateways, custom inference providers, and OpenAI-compatible endpoints.
| Orchestration Capability | Common Framework Constraints | AOa v2 Differentiators |
|---|---|---|
| Dynamic Task Routing | Static routing layouts or hardcoded graph designs that require predefined paths for all tasks. | Dynamic multi-agent task selection (PTME) that matches agent capability and effort level to the task. |
| Rate-Limit Handling | Basic retry loops that fail or block when hitting API rate limits or quota caps during long-run execution. | Checkpoint & resume scheduling that serializes task states and resumes automatically. |
| Parallel Workspace Isolation | Shared file access in a single directory, creating risk of overlapping writes or concurrent file conflicts. | Isolation of parallel tasks via independent Git Worktrees, ensuring zero concurrent write conflicts. |
| QA Verification Gates | Relying on the same agent to verify its own implementation, leading to self-confirming code hallucinations. | Mandatory "Worker != Tester" architectural split, routing validation tasks to independent tester agents. |
| Zero-Broker Message Bus | Reliance on heavy external database/broker backends (like Redis) or volatile process memory to sync state. | Lightweight, file-based state logs persisted in Git, allowing standard version control to act as the bus. |
Engineered for Fail-Safe Development
AOa v2 relies on standard, zero-dependency Python modules interacting directly with local system CLI binaries, Git systems, and flat files.
Git-Worktree Isolation
Instead of editing files inside the main active directory, the local coordinator provisions a clean, isolated git-worktree folder for each task (e.g. worktrees/task-102/). Parallel sub-agents execute inside their own directories; no two agents touch the same code at once, removing merge conflicts entirely.
Rate-Limit-as-Scheduling
If a CLI agent hits an API block or gets throttled by a provider's rate limits, it serializes its execution history, current script state, and the remaining execution steps into a local checkpoint JSON file under tasks/snapshots/. The task status transitions to a sleep queue and resumes once limits expire.
Pre-Task Spec Gates
To avoid scope creep and alignment drift, AOa v2 blocks execution of Medium (M), Large (L), and XL tasks until the agent compiles and validates a pre-task specification file. The spec includes concrete completion requirements, anticipated files to edit, and explicit verification criteria.
Per-Task Model & Effort Gating
Andy generates a task plan containing recommended models and effort tiers (e.g. implementation model with High Effort for complex code edits, research model with Low Effort for basic research). The local model orchestrator reviews recommendations, applies overrides, writes to a local decision log, and triggers setup.
Roadmap Milestones
Core v2 orchestration features are now shipped and operational, shifting our focus to remote headless servers and cron automation.
Team-of-Teams (ToT) Parallel Execution
Shipped in v2Enables spawning parallel, specialized sub-agent pools (implementation, research, and security) executing concurrently inside isolated workspaces. Independent tasks are resolved in parallel rather than queued sequentially, reducing bottleneck waits.
Per-Task Model & Effort Selection (PTME)
Shipped in v2Pre-dispatch analysis selects the optimal model type and reasoning effort levels based on task description. The local orchestrator acts as a gating review step before allocation, saving cost by matching task complexity to the correct model.
Self-hosted Headless VPS (Hostinger): Configure AOa v2 to run headless on a dedicated VPS. Execute CLI tasks continuously without interactive OAuth screens, utilizing scheduled local cron jobs and flat-file queues for 24/7 autonomous repository management.
What's New
The latest upgrades to the engine — shipped, tested, and live.
A third teammate comes online.
Our Gemini-powered agent now runs fully headless — no terminal babysitting. Work spreads across three AI agents (Claude, Codex, Gemini) so nothing waits in line.
Smarter task routing (PTME).
Every task is sized up and sent to the right model at the right effort level — like a dispatcher who knows exactly who's best for the job.
Team-of-Teams.
The orchestrator can spin up sub-teams that run in parallel, each owning a slice of the work, then hand results back for assembly.
It learns as it works.
Agents score their own performance and the orchestrator reflects after every review on whether it picked the right model and effort — so it keeps getting better.
Nothing ships unverified.
A strict worker-≠-tester rule: whoever built it never signs it off — a different agent independently checks the work before it's done.
A live control room.
A real-time dashboard shows which agent is on which task, right now.
Open-ready.
The framework was hardened and sanitized for public release.
Deploy Your Local Multi-Agent Team
The AOa v2 blueprint is fully open-source, written using standard Python libraries, and requires zero third-party package installations.
Set up your workspaces, configure your local agent credentials, and begin running parallel CLI developers.
View GitHub Repository# Clone the zero-dependency repository git clone https://github.com/InonB2/multi-agent-orchestration.git cd multi-agent-orchestration # Initialize the active task queue from sample template cp examples/sample_active_tasks.json tasks/active_tasks.json # Execute local model & effort decision gate python scripts/coordinator.py schedule-all >> Task plan parsed from Andy orchestrator. >> Task TASK-101 (Research): Decided research model (Medium) -> Spawning Worktree A. >> Task TASK-102 (Coding): Decided implementation model (High) -> Spawning Worktree B. >> Logged decisions inside D:/Claude Playground/tasks/decision_log.json >> Parallel execution of worktrees started successfully.