<!-- GENERATED FILE — do not edit README.md directly.
The source of truth is docs/readme/ (one file per section, assembled
in filename order). Edit the part, then run:
python scripts/build_readme.py
tests/test_readme_assembly.py pins this file to the parts. -->

DOS — the Dispatch Operating System

> ### Catch your AI agents when they lie about what they shipped.

> 📊 See it run on real repos: the scoreboard
> scores 15 popular AI-built repos (roborev, open-interpreter, crewAI, autogen, …)
> — how much agents wrote, which ones, and whether each commit's claim is backed
> by its own diff. Score yours: dos commit-audit --sweep --workspace . BASE..HEAD.

<p align="center">

<br>
<em>The whole pitch in one recording: the agent claims two features shipped; git backs one.
<code>dos verify</code> answers from the commits, the lie exits <code>1</code>, and a gate on that
exit code refuses the false "done". Every line is the real CLI's verbatim output —
<a href="https://github.com/anthony-chaudhary/dos-kernel/blob/master/scripts/build_caught_lie_cast.py"><code>scripts/build_caught_lie_cast.py</code></a> re-records it whenever the output changes.</em>
</p>

<p align="center">

<br>
<em>Run a fleet of agents on one repo. The left loop just feels like progress; the right one you can steer.
The only difference is a verdict DOS reads from the real world — here, git — never the agent's word.</em>
</p>

An AI agent will tell you it finished. DOS checks the real world instead of
taking its word — and the nearest piece of the real world is your git history.
An agent says it shipped the login endpoint; did it? Run one command,
dos verify, and it answers from the artifacts the work left behind, not from
what the agent typed: a commit backs the claim → SHIPPED, exit 0; nothing
landed → NOT_SHIPPED, exit 1. The agent's story never enters into it. (Git
is just the first witness DOS reads; the file tree, the clock, a CI status, a
test environment's own state are others — anything the agent didn't author.)

dos verify AUTH AUTH1   # → SHIPPED      AUTH AUTH1 e62f74d   (exit 0)
dos verify AUTH AUTH2   # → NOT_SHIPPED  AUTH AUTH2           (exit 1)

That's the smallest version. It scales up, too: point a dozen agents at one
repo — in CI, in a fleet, racing on the same files — and DOS also tells you
which ones are stepping on each other, which one is spinning in circles, and
which claim of "done" is real. Every answer comes from the artifacts (git, the
file tree, the clock), never the narration. It works on a plain git repo with
zero config and gets smarter the more you tell it, and the only thing you ever
install is one small Python package.

> ⚡ Just add it — two commands, zero decisions. From the repo where your
> agent works:
>
>

> pip install dos-kernel

> dos init --hooks auto   # finds the agent runtime(s) you already use, wires in the checks

> 

>
> From then on: your agent can't tell you "done" unless the work actually
> landed, two agents can't silently overwrite each other's files, and a run
> that stalls gets flagged instead of quietly spinning. Nothing about your
> workflow changes, and you don't need to learn any of the vocabulary below to
> be covered. It prints the one config file it wrote; deleting the dos hook
> entries there undoes it. (No runtime detected? It says so and lists the
> names to pick from — it never guesses.)

_{v0.29.0 · 5,600+ tests · CI: Python 3.11–3.13 on Linux + a Windows 3.13
smoke run · the only runtime dependency is PyYAML · MIT.}

> 🧭 Where to go next: the why & evidence (plain-words story, the 20-lines-of-bash answer, what's proven),
> wire it into your stack (MCP · hooks · install), the
> syscall + CLI reference, or, reading this as an AI agent?, AGENTS.md — build/test/check in three lines. The full map is the router just below.

> 🔤 Five words the rest of this page leans on. A plan is a named goal
> (AUTH); a phase is one shippable step of it (AUTH1); a lane is the
> slice of the file tree one agent may touch; the oracle is the part of DOS
> that reads the evidence and rules; a stamp is the mark a shipped phase
> leaves in a commit subject (AUTH1: …) — the thing the oracle greps for.
> That's the whole vocabulary.

<a id="who-this-is-for"></a>
<a id="the-plain-words-version"></a>

In plain words

A coding agent does work, then tells you how it went. Usually the story is true;
sometimes it's the cheerful "all work completed!" from a worker that shipped
nothing. With one agent you catch that yourself by re-reading its output — a real
tax you already pay. Run twenty at once and that tax stops being payable: nobody
reads everything, each worker grades its own homework, and the unchecked problems
pile up quietly until the codebase sorta works and nobody can safely change it.
DOS is the referee that never reads the story — it reads what happened (the
commit, the file, the clock) and hands you a verdict no narration can move. It
costs about an afternoon, has one runtime dependency, and stays in its lane: it
tells you what happened, never whether the code is good — quality stays with
your tests and reviews. (The full plain-words version.)

Measured, not asserted

…