Liza — Summary

Liza is a hardened multi-agent coding system (35k LOC Go + 92k test LOC) that wraps provider CLIs (Claude Code, Codex CLI, Kimi, Mistral, Gemini) in code-enforced supervisors and isolated git worktrees, enforcing adversarial doer/reviewer pairs on every task through a 43+ validation-rule state machine. The behavioral contract (contracts/CORE.md) loads as the agent system prompt, encoding 55+ failure modes with mechanical countermeasures, and mode selection (Pairing/Liza/Subagent) is auto-detected from bootstrap context. A liza CLI binary provides the full control surface: liza tui for a live Bubbletea dashboard showing system state, agent health, and task progression; liza spawn-agent, liza write-checkpoint, liza recover-agent for lifecycle management. The pipeline is a YAML-defined composable spec-driven workflow: goal → epics → user stories → implementation plans → adversarial coding cycles, all orchestrated by a Go supervisor that performs the deterministic actions while agents handle judgment. Multi-sprint autonomy, circuit-breaker pattern detection, and context handoff notes when agents approach context limits make Liza L4-level (Collaborative Agent Networks) per the AI engineering maturity map.

Differs from seeds: closest to bmad-method in multi-phase spec-driven pipeline with named agent personas, and claude-flow in parallel worktree isolation; but Liza is architecturally distinct because the supervisor is compiled Go code, not prompts — role boundaries are mechanically enforced, not suggested. Unlike all 11 seeds, Liza uses BYOM via provider CLIs (no API keys needed), and its adversarial doer/reviewer quorum is the only code-enforced adversarial review loop in the surveyed space.

Liza — Overview

Origin

Liza (liza-mas/liza) is developed by the liza-mas team under Apache-2.0 license, 5 contributors, 227 stars, 36 forks. Version 0.2.0, last commit 2026-05-26 (actively maintained). Written in Go (35k LOC + 92k test LOC) with Bubble Tea for the TUI. The name references a historical context: Liza Minnelli + the context of "disciplined multi coding agent system."

"Because 'it worked in the demo' is not what on-call engineers are looking for."

Philosophy

Liza is built around one conviction: behavioral trust is the unsolved problem in multi-agent coding systems. Most frameworks either (a) assume agents behave correctly (prompt-level governance) or (b) validate outputs (post-hoc checking). Liza enforces agent behavior mechanically through a Go supervisor that validates every state transition.

The framework explicitly catalogs 55+ agent failure modes with mechanical countermeasures — something no other framework in the space has published.

Three layers of agent usefulness:

• Behavior — behavioral contract (contracts/CORE.md) with T0/T1/T2 rule tiers
• Posture — original pairing postures (User Duck, Socratic Coach, Challenger)
• Know-How — 20+ composable skills

Positioning Quote

From a VP of Software Engineering (Accenture/Octo Technology):

"Multiple specialized agents work together on design, code, testing, and deployment. Humans orchestrate. This is typically what's happening with BMAD, BEADS, and LIZA. Very few organizations have genuinely reached this level in 2026."

BYOM Philosophy

"Liza wraps provider CLIs, not their APIs. This means your existing subscription (Claude Max, ChatGPT Pro, etc.) works — no API keys or per-token billing required."

This is a deliberate architectural choice enabling BYOM (Bring Your Own Model) for all 5 supported providers: Claude Code, Codex CLI, Kimi, Mistral, Gemini.

Key Manifesto Quote

"Without the contract, an agent that hits a problem it can't solve has two options: admit failure or fake progress. Its training overwhelmingly favors the second. Faking progress feels collaborative — look, I'm trying things! So it spirals."

"Under the contract, there's a third option: say 'I'm stuck' and mean it."

Liza — Architecture

Distribution

• Binary install: curl -fsSL install.sh | bash (installs to ~/.local/bin/liza)
• Build from source: Go 1.25.5+
• OS: Linux, macOS (Darwin); WSL2 on Windows

Repository Structure

cmd/
  liza/
    main.go, cmd_agent.go, cmd_task.go, cmd_worktree.go
    cmd_init.go, cmd_review.go, cmd_system.go, cmd_check.go
    rbac.go
contracts/
  CORE.md                         # Behavioral contract (system prompt)
  MULTI_AGENT_MODE.md             # Liza MAS contract
  PAIRING_MODE.md                 # Pairing mode contract
  SUBAGENT_MODE.md                # Subagent mode contract
  CONTRACT_FAILURE_MODE_MAP.md    # 55+ failure modes catalog
  AGENT_TOOLS.md                  # Tool permissions per role
  COLLABORATION_CONTINUITY.md     # Cross-session handoff rules
skills/
  adr-backfill/                   # Archaeological ADR reconstruction
  architecture-planning/
  black-box-red-testing/
  checkpoint-summary/
  clean-code/
  code-quality-assessment/
  code-review/
  code-spec-backfill/
  context-engineering/            # Prompt payload audit + optimization
  debugging/
  detailed-spec-writing/
  epic-writing/
  feynman/                        # Explain-it-simply technique
  generic-subagent/
  have-you-considered/
  lesson-capture/
  liza-logs/                      # Cross-agent log analysis
  software-architecture-review/
  spec-backfill/
  spec-review/
  systemic-thinking/
  testing/
  user-story-writing/
  white-box-red-testing/
internal/
  agent/                          # Agent lifecycle management
  models/                         # agent.go, task.go, sprint.go, state.go
  db/                             # State persistence
  git/                            # Worktree management
  interactive/                    # TUI
  ...
specs/                            # Liza's own specs
plans/                            # Implementation plans

Required Runtime

• Go 1.25.5+ (build) or binary release
• One of: Claude Code, Codex CLI, Kimi CLI, Mistral CLI, Gemini CLI (as worker agents)
• Git (worktree management)

Install

curl -fsSL https://raw.githubusercontent.com/liza-mas/liza/main/install.sh | bash

Or from release binaries.

Target AI Tools

BYOM — wraps provider CLIs:

• Claude Code (primary, best support)
• Codex CLI
• Kimi CLI
• Mistral
• Gemini

Liza — Components

CLI Binary: liza

Key subcommands (from cmd/liza/):

Behavioral Contracts (contracts/)

Agent Roles (from models/agent.go)

Status types: STARTING, IDLE, WORKING, REVIEWING, WAITING, HANDOFF, PLANNING

Role types (from MULTI_AGENT_MODE.md):

• Orchestrator — decomposes goals into tasks; no approval authority
• Coder — implements tasks; cannot self-approve or merge
• Code Reviewer — reviews and approves; cannot implement

Skills (24+)

State Machine: 43+ Validation Rules

From INVARIANTS.md — the task state machine enforces:

• DRAFT → IMPLEMENTING → READY_FOR_REVIEW → REVIEWING → APPROVED → MERGED
• Forbidden transitions (e.g., IMPLEMENTING → MERGED skips review)
• Required fields per state (e.g., IMPLEMENTING requires assigned_to, worktree, base_commit)
• Role boundaries enforced in code, not prompts

Blackboard (state.yaml)

YAML blackboard acts as:

• Kanban board with full historized state
• Support for PR-like review comments from reviewer agents
• Sprint state tracking
• Kill switches: PAUSE, ABORT, CHECKPOINT

Liza — Uniqueness & Positioning

Differs From Seeds

Closest seed is bmad-method in multi-phase spec-driven pipeline with named agent personas and adversarial review. The architectural delta: Liza's role boundaries are enforced by compiled Go code (43+ validation rules in validate_task.go), not by prompt suggestions. Compared to claude-flow (parallel worktrees), Liza adds YAML blackboard coordination, formal task state machine, and mandatory adversarial review pairs. No seed ships:

• A mechanical behavioral contract with T0 Hard Invariants (mandatory halt on violation)
• Code-enforced role boundaries preventing self-approval and skipping review
• A 55+ failure mode catalog with mechanical countermeasures
• An empirically tested provider compliance matrix across 5 CLIs

Distinctive Opinion

"Behavioral trust is the unsolved problem. Mechanical enforcement — not prompt engineering — is the solution."

The BYOM via CLI approach (wrapping provider CLIs rather than using APIs) is a second distinctive opinion: team subscription-based access (Claude Max, ChatGPT Pro) without API keys is a real-world deployment advantage.

Positioning vs. Competitors

From README competitive table:

Where Liza leads vs. others: failure mode catalog, adversarial pairs on every task, code-enforced role boundaries, provider compliance matrix, multi-sprint continuity.

Where others lead: ecosystem (BMAD 45k+ stars vs. Liza 227), upstream planning breadth (BMAD covers brainstorming→PRD), cost tracking (Paperclip), domain flexibility (CrewAI works for any domain; Liza is software-only).

Observable Failure Modes

1. Go binary complexity: 35k LOC + 92k test LOC means significant operational complexity. Bugs in the supervisor can block all agents.
2. CLI wrapping brittleness: Provider CLI updates can break Liza's wrapping layer. README acknowledges this: "regressions from provider CLI updates" is a known friction.
3. Single-provider gap: Not all providers are equal — README notes "not all are made equal" after benchmarking 5 providers. Some providers may have compatibility issues.
4. Spec quality dependency: The goal document (~200 lines) drives the entire pipeline. Ambiguity in the goal document cascades into incorrect epics and user stories.
5. Limited ecosystem: 227 stars vs. BMAD's 45k+. Community support, tutorials, and third-party integrations are sparse.