Skip to main content
Liza is a hardened Multi-Agent Coding System built around a single premise: agents that look impressive in demos routinely fail in production. Without structural enforcement, an agent that hits a hard problem has two options — admit failure or fake progress. Training pressure overwhelmingly favors the second. Liza adds a third option by wrapping every LLM coding agent with a behavioral contract, adversarial doer/reviewer pairs, and a deterministic Go supervisor that mechanically enforces state transitions, role boundaries, and merge authority. The result is code you can ship on the first pass, with an auditable trail to prove it.

​
The Problem Liza Solves

Standard LLM coding agents are sycophantic by design. Sycophancy drives engagement; acting fast with little thinking controls inference costs. These incentives are set by model providers — they will not self-correct. The consequences are predictable: spiral debugging sessions dressed up as hypotheses, diffs that grow while moving away from a solution, and context windows full of confident wrong turns. Liza’s behavioral contract addresses 55+ documented LLM failure modes, each mapped to a specific countermeasure. The contract doesn’t add external scaffolding — it enforces governance intrinsically. Agents operating under the contract stop sounding like enthusiastic assistants and start behaving like senior peers: direct, opinionated, and willing to say “I’m stuck” when they are.

​
Three Operating Modes

Liza offers three modes that share the same behavioral contract and differ in the degree of autonomy and human involvement.

Pairing

You supervise every step. The agent codes under the behavioral contract; you steer, approve, and review. The fastest way to experience the contract.

Adversarial Pairing

A doer agent writes and a reviewer agent challenges through a shared Markdown blackboard. Higher confidence on complex tasks without launching the full pipeline.

Multi-Agent

Fully autonomous goal-to-merge pipeline. Thirteen roles across four phases, adversarial pairs on every task, human checkpoints between sprints.
When to use each mode:

​
Key Differentiators

​
Behavioral Contracts (55+ Failure Modes)

Liza’s behavioral contract is a curated catalog of LLM failure modes — sycophancy, premature convergence, fabricated progress, over-confident refactoring — each with a specific mechanical countermeasure. The contract is loaded into every agent’s bootstrap prompt and enforced by the supervisor. It cannot be bypassed by an agent choosing to ignore instructions.

​
Adversarial Doer/Reviewer Pairs

Every activity in Liza is dual. An epic planner pairs with an epic plan reviewer; a coder pairs with a code reviewer. The interaction mirrors a real PR review cycle: submission, structured feedback comments, verdict, revised submission, and final approval. Nothing merges without reviewer sign-off.

​
Deterministic Go Supervisors

Liza is not a prompt collection. It ships 35,000 lines of Go plus 92,000 lines of tests. The Go supervisor wraps every agent and handles all deterministic actions — worktree management, state machine transitions, TDD gate enforcement, merge authority — leaving judgment to the agent. Critical invariants cannot be fabricated, skipped, or interpreted flexibly.

​
Crash Recovery and Resilience

Liza is built for long, complex runs:
  • Circuit breaker — pattern detection (loops, repeated failures) triggers an automatic sprint checkpoint before damage accumulates.
  • Crash recovery — recover-agent and recover-task commands provide idempotent cleanup after hard crashes.
  • Context handoff — agents hand off with structured notes when approaching context limits, so no work is lost.

​
Git Worktree Isolation

Every agent task runs in its own isolated git worktree. Agents cannot accidentally overwrite each other’s in-progress work, and the supervisor controls merges deterministically. The worktree structure also makes it straightforward to inspect, diff, or revert any individual task.

​
Provider Compatibility

Liza wraps provider CLIs, not their APIs. Your existing subscription (Claude Max, ChatGPT Pro) works without API keys or per-token billing. Not all providers are equally capable of following the behavioral contract.
Claude and Codex are the recommended providers for all three modes. Kimi, Mistral, and Gemini are supported for experimentation but are not recommended as primary providers for production runs.

​
Architecture at a Glance

Liza is a hybrid system. The agents are standard coding agent CLIs doing what they do best: judgment, reasoning, and writing code. The supervisor is deterministic Go code doing what it does best: enforcing rules mechanically. The two layers never swap roles. The 13 roles are organized across four pipeline phases:
  • Specification phase — Orchestrator, Epic Planner/Reviewer, US Writer/Reviewer
  • Architecture phase — Orchestrator, Architect/Reviewer
  • Coding phase — Orchestrator, Code Planner/Reviewer, Coder/Reviewer
  • Integration phase — Integration Analyst/Reviewer, Coder/Reviewer
A YAML blackboard (state.yaml) acts as the shared Kanban board and PR comment thread, giving you a full auditable history of every agent action, state transition, and reviewer verdict.

Quickstart

Install Liza and run your first session in under 10 minutes.

Operating Modes

Deep dive into Pairing, Adversarial Pairing, and Multi-Agent modes.