kranz.

MISSION CONTROL FOR CODING AGENTS

Agent work.
Human authority.

Give your coding agents a mission.
Keep the decisions that matter.

Kranz turns a goal into an approved plan, independently validated work, and a record you can trust. All in your Git repository.

See how it works Read the docs

Local-first · Built in Rust · Git-native

THE ANATOMY OF A MISSION4 CHECKPOINTS
MISSION / 024Illustrative run

Add an authenticated API endpoint

kranz/mission-024
  1. Plan approvedScope, criteria, and base commit pinned
    YOU
  2. Work deliveredChanges committed in an isolated worktree
    WORKER
  3. Independently validatedContract checks + fresh-context scrutiny
    REVIEWERS
  4. Your call to mergeReview the evidence. Approve the change.
    YOU
Every step recorded. Every decision traceable.
The agent writes the code. Kranz owns the gates.

YOUR AGENTS.
ONE GOVERNANCE LAYER.

Claude Code is the default. Role and sandbox support varies by backend.

ONE MISSION.
THREE WAYS IN.

THE WORKFLOW

From intent to evidence.

One durable mission.
Four deliberate steps.

  1. 01

    Define the outcome

    Describe your goal. An orchestrator shapes it into milestones and testable acceptance criteria.

    CONTRACT FIRST
  2. 02

    Approve the plan

    Review the scope, cost estimate, and permissions. Approval pins the plan and the Git base.

    HUMAN CONSENT
  3. 03

    Dispatch & validate

    Workers implement. Separate reviewers inspect the diff and judge engine-run contract checks.

    SEPARATED ROLES
  4. 04

    Review & merge

    Inspect the report. Your merge action runs base-owned gates against the exact integration commit.

    EVIDENCE INCLUDED

INSIDE MISSION CONTROL

The work. And the evidence.

See what ran, who reviewed it,
and why it passed.

WEB DASHBOARD View full size
Kranz Mission Control showing a completed mission, separate worker and validator sessions marked PASS, scrutiny review evidence, model assignments, usage, and milestone progress.
Independent review, in context.

Inspect agent sessions, reviewer findings, usage, and progress without losing the mission around them.

RECORDED MISSION · JUL 2026

WHAT MAKES KRANZ DIFFERENT

“It passed”
needs a paper trail.

Know what was approved, what was checked, and why a change was allowed through.

Success is defined before the work.

Behavioral contracts make the outcome testable. An empty deliverable fails honestly.

The worker never grades its own work.

Fresh reviewers judge the diff and captured checks, without the worker’s reasoning.

The change cannot weaken its merge gates.

Checks come from the base branch. Only the exact integration commit that passed can advance it.

THE CAPABILITIES

Control at every step.

01

Planning & approval

An outcome becomes a contract.
  • Interactive planning. Shape plain-language goals into milestones, features, behavioral assertions, and validation commands.
  • Informed approval. Review estimates, permissions, and scope; pin the plan, applicable rules, and Git base at consent.
  • A Git-native backlog. Markdown tickets, dependencies, discussion notes, lifecycle states, and asynchronous plan drafting.
  • Durable queues. Approve now and drain later, with recoverable claims and one active mission per repository.
  • Readiness checks. Check runtime discovery, authentication, models, environment prerequisites, and merge gates before spending.
  • Mid-mission revisions. Change the remaining scope with a fresh approval while preserving completed milestones.
Explore planning & tickets
02

Isolation & permissions

Clear boundaries around agent actions.
  • Dedicated worktrees. Isolate mission changes from your primary checkout, with supervised child processes and cleanup.
  • Roles with distinct authority. Separate planning, implementation, and review permissions; record denials and human command grants.
  • Explicit credentials. Clear child environments and admit only sanctioned backend credentials and declared secret channels.
  • Filesystem & network boundaries. Enforce supported sandbox profiles and filtered network access. Worker sandbox enforcement currently requires Claude Code.
  • Contained validators. Review in disposable snapshots with the real source tree denied; unsupported containment fails closed by default.
  • Secret protection. Scan and redact at log ingestion, scan before merge, and audit fingerprint-based waivers. Separate read and mutation tokens protect the API.
Explore isolation & sandboxing
03

Validation & delivery

Evidence before a green light.
  • Contract checks. Engine-run commands capture test, build, and lint results; judgment assertions are checked against the mission diff.
  • Two independent review roles. Functional validation judges captured results. Scrutiny checks intent, weak tests, and integration seams.
  • Reviewer independence. Optionally require a different model family for review, pinned at approval and enforced across fallback choices.
  • Functional UI review. Configure browser or computer-use QA for repositories with a runnable, scriptable application.
  • Bounded recovery. Cap repair cycles and worker respawns. Unresolved work becomes blocked; a mission with no feature deliverable fails.
  • Gated local merging. Run base-owned gates in a scratch worktree against the pinned integration commit. The human triggers the merge; local Kranz never pushes.
Explore validation & merge gates
04

Evidence & cost

An audit trail you can replay.
  • Durable event history. An append-only, hash-chained log records mission events and rebuilds state after interruption or a stale snapshot.
  • Provenance replay. Reconstruct gates, backend and model identities, prompt hashes, escalations, and human decisions from the log.
  • Completion reports. Keep committed plans and reports with delivered features, validation history, waived findings, elapsed time, and costs.
  • Spend visibility. Track reported tokens and costs, configured run budgets, calibrated estimates, task-class outcomes, and cost per merged change.
  • Trust metrics. Measure autonomy, interventions, approval latency, and defects later traced to missions that had passed.
  • Portable evidence. Export OpenTelemetry traces, escalation ledgers, execution traces, and training corpora from recorded mission evidence.
Explore evidence & metrics
05

Engineering standards

House rules with accountable exceptions.
  • Private knowledge packs. Keep domain knowledge and organization-specific policy outside the domain-free core.
  • Flight Rules. Manage versioned SHOULD/MUST standards with deterministic applicability and revisions pinned at approval.
  • Checks that fit the rule. Bind deterministic, contextual, and human review mechanisms to the right stage of the mission.
  • Exact human waivers. Record authorized exceptions, their rationale, and the specific findings and rule revisions they cover.
  • Review beyond code. Apply the evidence workflow to tracked specification and incident artifacts, with a required review output.
  • Learn from outcomes. Retain mission lessons and repository knowledge, and report rule effectiveness across missions.
Explore Flight Rules
06

Mission operations

Steer the work from where you are.
  • CLI, web & desktop. Plan, approve, run, and inspect missions in the terminal, Mission Control dashboard, or Tauri desktop shell.
  • Slack control. Plan in threads, approve, steer, configure, and receive mission notifications with authorized-user spend controls.
  • Even Realities G2 glasses. A lightweight client uses the mission API for glanceable status and controls. Hardware validation is still pending.
  • Live steering. Message, interrupt, pause, resume, unblock, or abandon; queue role and model changes for subsequent sessions.
  • Multiple repositories. Serve a host catalog with repository-specific missions, queues, configuration, and Slack routing.
  • Optional parallel workers. Dispatch independent features in separate worktrees and integrate in declared order. Sequential execution remains the default.
  • Crash recovery & hygiene. Resume from logged progress, recover provably dead locks, and clean or archive old missions. Core CLI support spans macOS, Linux, and Windows.
Explore mission operations
07

Backends & integrations

Bring your agents and existing workflows.
  • Backend choice by role. Claude Code, Codex CLI, Factory Droid, Kimi Code, Cursor, ACP-compatible agents, and OpenAI-compatible local inference.
  • Tracked routing policy. Base-owned rules select backends and models within declared role, readiness, and containment constraints.
  • Divergent candidates for review. Heterogeneous dispatch compares agent outputs as evidence, with explicit cost consent and no automatically merged winner.
  • Headless automation. Feed a plan to kranz exec; receive distinct complete, failed, blocked, or underspecified exit codes.
  • API & event streams. Build clients against the REST API and live WebSocket/SSE mission feeds.
  • External work intake. Integrate Gas City / Beads work, import OpenSpec changes, and configure workspace bootstrap and data hooks.
Explore backends & setup

AVAILABILITY Core workflows run locally. Cloud missions are a preview; the Even Realities G2 glasses client awaits hardware validation. Backend, model, and sandbox capabilities vary.

PUT YOUR NEXT CHANGE ON A MISSION

Your repo. Your agents.
Your call.

Explore the source
IN YOUR REPOSITORY 
# Initialize and check your setup
kranz init
kranz ready

# Plan, approve, then run
kranz plan "Add an API endpoint with tests"
kranz run

Start with the source install. Bring Git, Rust 1.88+, and an installed, authenticated agent runtime.