Open-source lifecycle management

kaos-control

Turn ideas into shipped, enterprise-grade releases — without losing the plot, blowing your token budget, or leaking your code to a third party.

A single Go binary that walks every idea through capture, requirements, planning, code, tests, and release as markdown artefacts in a git repo. You choose which AI model runs each role — controlling costs and keeping sensitive code on your own hardware.

View on GitHub Download
kaos-control dashboard showing a project lifecycle with ideas, requirements, plans, and a 3D artefact graph linking each stage

Walkthrough

Watch the Demo

A short walkthrough — setting up kaos-control, adding a project, and building a website end-to-end.

Why this exists

The Problem

The constraint isn't ideas — it's the structure to act on them. Agentic IDEs write code brilliantly but leave the hard questions unanswered: where ideas come from and how they're captured, how requirements get planned and assigned, how releases get cut and traced back to the original ask.

Two invisible costs compound the chaos. Token spend is opaque — you know you're burning money, but not on what. And every prompt you send to a hosted model is a piece of your product leaving your machine: architectural decisions, schemas, the quiet competitive moat that serious software lives in.

The bottleneck shifted. It stopped being "can the code get written?" and became "do I know what I'm asking for?" and "where is my code going while it's being written?" kaos-control was built to answer both questions at once.

What it is

Overview

kaos-control is a single Go binary — around 250 MB — with an embedded web UI, SQLite for indexing, and flat markdown files with YAML frontmatter as the source of truth. Run it on your laptop, a Linux box, or a tmux session you SSH into from anywhere.

Every piece of work is an idea, an enhancement, or a defect. Each walks configurable stages — capture, requirements, planning, development, tests, release — producing a markdown artefact at every step. The artefacts live in git. Lineage links every deployed line of code back to the original idea that asked for it.

Roles — requirements analyst, planner, developer, QA — are played by agents or humans interchangeably. The role contract is the same either way: produce the artefact. If it isn't written down, it didn't happen.

Diagram showing the kaos-control lifecycle: idea flows through requirements, backend plan, frontend plan, and test plan, then into development and finally a release

What's included

Features

Lifecycle & Lineage

Every artefact shares a lineage slug and a monotonic index across stages. Every deployed line of code traces to the original idea, with nothing lost between capture and release.

Agents per Role

Requirements analyst, planner, frontend developer, backend developer, QA. Assign Claude Code, Ollama, or a human to any role. Roles are interchangeable; the artefact contract stays the same.

Cost & Privacy Levers

Configure a different model per role. Opus where thinking quality dominates; Haiku for QA and test execution; local Ollama for code that should never leave your machine. Token spend is logged per run.

Visualisation

3D force graph, 2D Cytoscape graph, Kanban board, Gantt chart, and roadmap view over the same artefact data. The blocked column is the human work queue — anything there needs a person.

DevOps Pipelines

Declarative YAML pipelines in your project's lifecycle directory. Trigger build, deploy, and release sequences from the UI. Per-step output streams to the browser over WebSocket. Role-gated.

Local-First & Open Source

One binary. No SaaS, no phone-home, no required cloud account. Your artefacts live in your git repo. Pull the network cable and the workflow keeps going. Released under AGPLv3.

The lifecycle

How It Works

An idea enters as a rough sentence — in your own voice. kaos-control classifies it, generates a proper artefact with a lineage slug, and links it to related work it finds on the way through.

Capture

Paste a vague email or a one-liner. The system generates a proper idea artefact and links it to related work.

Requirements & Planning

The requirements analyst clarifies scope; the planner produces backend, frontend, and test plans — each as a linked artefact.

Develop & Release

Developers implement in parallel; defects raise artefacts automatically. When the artefact cluster is green, move the feature into a release with a click.

Cloud architecture diagram showing kaos-control running locally, with optional connections to hosted Claude models and local Ollama for on-premise inference

See it in action

Roadmap

kaos-control's own roadmap lives inside the running app and is dogfooded daily. Features cluster around the releases they belong to; unscheduled work waits in the backlog. Same artefacts, multiple lenses.

3D force-graph view of the kaos-control roadmap: feature nodes orbit their release node; colour indicates status — green for done, amber for in progress, grey for backlog
3D graph — features orbit their release node
Roadmap list view showing planned releases as rows with their assigned artefacts, target dates, and completion status
Roadmap list — releases, dates, and artefact assignments

Who it's built for

Who It's For

Lead Developers

Introduce agents into a real team workflow without giving up code review, tests, release discipline, or the option to keep sensitive code off third-party servers.

CTOs & Tech Leaders

Read documents and approve things rather than tinkering with an AI IDE. The discipline is encoded in CLAUDE.md; you inherit it by opening the project.

Founders & Entrepreneurs

Running a one-person dev shop? kaos-control gives you the structure to track what you've already built and plan what comes next without losing your mind.

Product Managers & Owners

Capture vague ideas faithfully, produce traceable artefacts, and show stakeholders exactly what's in each release and where every feature came from.

News & updates

What's New

kaos-control is built in the open, using itself. Every release is cut from artefacts you can read in the repo — here's what has landed recently.

  1. Article

    From Idea to Release: Two Months of kaos-control

    Sixty days from first public release to v0.2, written up in full: what the agents got right, where they needed a human, and why AI agents need guardrails more than they need capability.

    Read on Substack →

  2. v0.2.0

    kaos-control 0.2 released

    Around 405 commits since v0.1.3 — enough new behaviour to earn a minor version bump rather than a patch. The theme is constraint: giving agents tighter rails and giving you better places to step in.

    • Artefacts nest in subdirectories under any stage, with path chips and breadcrumb navigation.
    • Open questions get a guided resolution modal and an awaiting-response badge in the menu bar — no more hand-editing markdown to unblock a run.
    • DevOps pipeline run history with expandable per-run logs, automatic pruning, and a kaos-control devops list | status | run CLI.
    • New claude-env driver points any role at a local or alternative model endpoint.
    • Reliability and security hardening — transient auth failures re-queue instead of pausing, 13 CVEs cleared, Go 1.25.12.

    Full release notes →

  3. v0.1.3

    Reports, releases, and a UI that fits a phone

    A Reports view breaking down agent cost, tokens, and time-to-first-token per model and per agent; releases promoted to first-class artefacts; single-submit idea capture with auto-triage; a mobile-responsive UI; and new Gemini and Codex CLI agent drivers.

    Full release notes →

Every release, with checksums and upgrade notes, is on GitHub Releases. Longer write-ups land on Substack.

Ready to ship?

Get Started

Pre-built single-binary archives are published on GitHub Releases for macOS (Intel + Apple Silicon), Linux (x86-64 + arm64), and Windows (x86-64). Download, unzip, and run. 

# Download the archive for your platform (replace VERSION and PLATFORM as needed)
VERSION=0.2.0
curl -L -o kaos-control.zip \
  https://github.com/kcsinclair/kaos-control/releases/download/v${VERSION}/kaos-control-${VERSION}-darwin-arm64.zip
unzip kaos-control.zip
./kaos-control-${VERSION}/kaos-control

See the README for platform-specific steps, checksum verification, and first-run setup.

View on GitHub Download

Available under the GNU AGPLv3 licence. Commercial licence available on request.