Maverick — Summary

Maverick is a Python CLI (maverick) that orchestrates a complete PRD-to-deployed-code pipeline on top of airframe, a vendor-neutral agent runtime protocol. Its central architectural metaphor is the "bead" — every unit of work (implementation task, review finding, human escalation, correction task) is a bead in a dependency graph managed by the bd CLI tool, ensuring all work flows through the same tracking system regardless of whether it was created by an agent or a human. The pipeline has four commands: plan (generate flight plan from PRD), refuel (decompose into work units with acceptance criteria), fly (implement + validate per bead), and land (curate commit history + merge). What distinguishes Maverick from other PRD frameworks is the enriched code review context — every review agent receives the full work unit spec, a pre-flight briefing (contrarian findings, risk assessment), and runway historical context from previous bead outcomes. It also supports five canonical agent roles (implement, review, briefing, decompose, generate) with per-role model binding in maverick.yaml. At version 0.2.0.dev9 with 3 stars, Maverick is early-stage but architecturally sophisticated. Compared to seeds, it most resembles taskmaster-ai (bead-based task graph, per-task acceptance criteria, multi-agent execution) but adds enriched review context, multi-provider binding per role, and Jujutsu VCS instead of Git.

Maverick — Overview

Origin

Created by get2knowio (get2knowio/maverick). MIT license. Version 0.2.0.dev9 (alpha). Pushed 2026-05-26 (very active — updated same day as analysis). Python 3.11+.

Philosophy

From README:

"Everything is a bead. A bead is a unit of work managed by the bd CLI tool. Implementation beads, review findings, human escalations, and correction tasks all live in the same dependency graph."

Maverick is built on the premise that agent-generated code review is only valuable if the reviewer has the same context as the implementer. Most review agents receive only the diff; Maverick's reviewers receive: the full work unit spec (acceptance criteria, file scope), a pre-flight briefing (contrarian findings, risk assessment), and runway historical context (outcomes of similar past beads). This "enriched review context" is the framework's primary differentiator.

The second premise is deterministic spec compliance — before any review, a grep-based convention checker (maverick fly) catches project-specific antipatterns (e.g., unwrap() in runtime code, blocking subprocess calls in async functions) without requiring a model to "know" the rules.

Key concepts

• Bead: Unit of work with acceptance criteria, file scope, priority, and status
• Flight plan: The structured decomposition of a PRD into epics
• Runway: Knowledge store of episodic records from past bead outcomes
• Refuel: Decompose a flight plan into work units (beads)
• Fly: Implement + validate beads autonomously
• Land: Curate commit history and merge

Provider support

maverick.yaml maps five canonical roles to any of: claude (OAuth via Claude Max), github-copilot, opencode, opencode-go, opencode-zen, openrouter, bedrock

VCS choice

Jujutsu (jj) for write operations. GitPython for read-only operations. This is unusual — no other framework in this batch uses Jujutsu.

Maverick — Architecture

Distribution

• Python package: maverick-cli
• Binary: maverick (also maverick-cli)
• Install: uv tool install maverick-cli
• Or: uv tool install git+https://github.com/get2knowio/maverick.git
• Version: 0.2.0.dev9

Required runtime

• Python >= 3.11
• uv (fast Python package manager)
• gh (GitHub CLI)
• jj (Jujutsu VCS)
• bd (bead/work-item management CLI)
• Authentication for at least one airframe provider

Key dependencies

airframe-agents[all]>=0.9.0rc1  # vendor-neutral agent runtime
burr>=0.40                       # Apache Burr workflow state machines
pydantic>=2.0                    # Data models
click>=8.1                       # CLI
rich>=13.0                       # Terminal UI
structlog>=24.1                  # Structured logging
pygithub>=2.1                    # GitHub operations
rank-bm25>=0.2.2                 # BM25 text search for runway

Directory tree (project state)

<project>/
├── maverick.yaml              # Role→provider binding, conventions
├── specs/                     # Per-bead feature specs (001-xxx/, 002-xxx/)
│   └── 001-maverick-foundation/
│       └── spec.md
├── .maverick/
│   └── runway/                # Episodic knowledge store
├── .specify/
│   ├── memory/
│   ├── scripts/
│   └── templates/
├── .claude/
│   ├── commands/
│   │   └── speckit.*          # 9 speckit-derived slash commands
│   └── skills/
└── CLAUDE.md

Airframe providers

claude, github-copilot, opencode, opencode-go, opencode-zen, openrouter, bedrock — each speaks its native vendor SDK directly.

Workflow engine

Apache Burr Application state machines. Each command (plan, refuel, fly) is a Burr Application of @action-decorated async functions over a per-workflow Squadron that owns the airframe runtimes. Single-process, all coroutines on one event loop.

Target AI tools

Claude (primary), GitHub Copilot, OpenCode, OpenRouter, AWS Bedrock

Maverick — Components

CLI Commands

Speckit Slash Commands (9, from spec-kit)

Maverick bundles speckit-derived commands in .claude/commands/:

Five Canonical Agent Roles (configured in maverick.yaml)

Bead Lifecycle

queued → assigned → in_progress → review → [approve → done] | [reject → correction_bead] | [defer → human_bead]

State Files

Maverick — Uniqueness

Differs from Seeds

Closest seed is taskmaster-ai (task graph with acceptance criteria, per-task decomposition, multi-agent execution). Maverick differs from taskmaster-ai in four ways: (1) enriched review context — Maverick's review agents receive the bead spec + contrarian briefing + runway history, not just the diff; (2) multi-provider role binding — five canonical roles are each independently configurable to any supported provider, whereas taskmaster-ai hard-codes its model tiers; (3) Jujutsu VCS for write operations, providing snapshot/rollback safety that Git branches alone don't offer; (4) human-in-the-loop escalation as a first-class primitive — when agents exhaust fix attempts, the work becomes a human-assigned bead rather than a failure, enabling mobile-friendly human review. The Apache Burr state machine as the workflow engine is unique in this batch — no other framework uses a formal state machine library.

Positioning

Maverick is the most architecturally sophisticated PRD-to-code pipeline in this batch that isn't Loki Mode. It is distinguished by the enriched review model and the bead-based unified work graph (agents and humans create work for each other in the same graph). It targets teams running Claude Max subscription OAuth or GitHub Copilot without separate API keys.

Observable Failure Modes

1. Alpha quality (0.2.0.dev9): API instability expected. Not recommended for production.
2. Jujutsu requirement: jj is not widely installed. Adds a non-trivial prerequisite.
3. bd CLI dependency: The bead management tool is a separate product — teams must adopt or integrate it.
4. Airframe dependency at rc1: airframe-agents>=0.9.0rc1 is itself pre-release.
5. No web UI: The maverick review interface is terminal-only, limiting accessibility for non-developer stakeholders.
6. Cross-epic serialization: All epics serialize even when independent, limiting parallelism for large multi-epic projects.