AI agents write your code. Thea shows what changed, which checks ran and who let it merge.
Not a smarter agent. An independent record of what each change passed.
An agent's summary is self-reported. Thea replaces it with the exit codes of your formatter, type checker and tests.
Rules run at commit and again in CI. A skipped check counts as a failure.
A refused change is recorded with the guard that stops it. 105 failure shapes closed so far.
Which agents ran, what they changed, which checks passed. It reads Thea's records and never judges.
Claude Code, Codex, opencode and Hermes, read from each runtime's own session files.
PASS, FAIL or NOT RUN for every changed file. It never shows a green it did not read.
The failure ledger: every shape an agent repeated and the guard that now stops it.
Your own toolchain decides. The exit code is the verdict, never the agent.
Thea is held to the rules it enforces. A check that could not run says so.
Every command returns stable JSON and an exit code. Everyone reads one record.
Agents load one file's route, not the whole repository.
Generated from a recorded run of contract 3.52.0. See the benchmarks
Every verdict auditable, every rule reviewable code. Nothing leaves your infrastructure.
CLI, hooks, MCP server and CI check on contract 3.52.0. Free and MIT licensed.
A local Mac app that shows every agent, check and repeated mistake. Nothing leaves the machine.
A GitHub check and one comment per pull request: which gates ran, passed, were skipped or refused.
Opt-in. Ships verdicts, never source code. Rules such as "no agent merges to main without the security gate".
A signed receipt that a change passed its own toolchain on a runner its author did not control.
Enforcement is never paywalled. Plans differ only in how many agents connect at once.
Install in minutes. The next change that skips a check does not land, and you see why.
One engine, from one developer to a whole organization.
"All tests pass" is a claim. Thea replaces it with evidence you read in a second.
One versioned contract gives every agent and pipeline the same answer.
An instruction file cannot stop an agent. Every Thea control is enforced, tested and recorded.
Observe, then block, then govern. Each stage is one step; your agents stay as they are.
Agents ask before they edit. Nothing blocks yet.
Add the git hook and required CI check. Failed changes cannot merge.
Turn on controls, share the failure ledger across repositories and give leads a dashboard.
The CLI, hooks and MCP server run locally over standard input and output.
A check in your own GitHub Actions marks every pull request.
A self-hosted control plane for shared policy, history and audit.
Start free, or join the Business design-partner program.
Eight layers. Each answers one thing an agent should never guess.
One contract, every surface. Three ship today.
Once is a bug. Twice is a rule.
How often it recurred, the guard that refuses it, the move that replaces it.
The move, when it applies and how it was verified.
Every declaration must resolve to the file that implements it, or the build fails.
agreement.lock · atlas.py checkAgents ask for one file's route instead of reading the tree.
verify.py context_costNo calendar dates in tracked text, no unbounded unpushed work, no hand edits to generated files.
dated claims · unpushed_bound · generated filesEvery language carries a guide, a card and a manifest.
languages/ · cards · instrumentsEach hard invariant names the function that enforces it. A control with no enforcer is refused.
thea invariantsSame five steps for any agent. Each verdict is an exit code.
Review gives an opinion. Thea gives a standard: one file that defines what proves a change.
The contract, gates and language packs are open source.
A README badge that opens the latest verdict.
Signed verdicts an auditor can check without rerunning.
README, AGENTS.md, CI config and tribal knowledge become one contract the build checks.
The agent asks which checks apply. The change cannot merge until they pass.
One record per file: route, tier, gates, past lessons and the next command.
The numbered commands that prove a change to this exact file.
Exit 0 only if every gate passed. NOT RUN is never a pass.
Push, pull request and merge in one step. Refused on conflict.
The same file record, framed for its audience with --frame.
Pass a class with --change; the plan adds the gates that class requires on top of the file's own.
scripts/verify.py runs each of these once and exits 0 only if all of them pass.
The agent builds. Thea checks the work and remembers every defect.
Every change shows which checks ran and passed.
A failed or skipped check stops the change at commit and at pull request.
A mistake seen twice becomes a tested rule.
Claude Code, Codex, opencode, Hermes or a script, with the tools you already have.
Agents ask for one file's checks, not the whole repository: 89% fewer tokens, measured.
MIT licensed, on your machine. No account, nothing to host.
Agents report "done" whether or not anything was checked.
"All tests pass." Which tests, run where?
A claim is not evidence. The diff does not say what ran.
Rules in a README are suggestions.
Docs describe the process. Nothing stops an agent skipping a step.
The same mistake, every week.
Each session starts from zero and repeats last week's failure.
Thea holds every agent to the same contract.
Contract · Port · Gates · Verify · Enforce · Control · Memory
Thea adds proof, a verdict and a memory.
Any agent, unchanged.
The exact commands that prove it. Riskier changes get more.
PASS, FAIL or NOT RUN. Nothing is taken on the agent's word.
A failed change cannot land. A repeat mistake becomes a rule.
Columns are categories, not named products.
Recorded runs. Each figure names the instrument behind it, so you can rerun it.
README generated block · 3.52.0
with Thea against 59% blind, across 11 models from 5 providers
abtest.py · 11 models · 2,409 questionsplanted broken commits refused at the hook
enforce.py · v3.52.0planted mistake kinds, each refused by a test
planted suite · 3.52.0One recorded python scripts/verify.py on a working branch. It exited 1, and the record says exactly why.
failure shapes filed, each with a guard; 40 success moves that replace them.
control tests passing in the same run; each plants a bypass that must be refused.
Scope: these are evidence for routing, checks and refusals, not for end-to-end task success.
Same model, same edit. Left is illustrative; right is a recorded Thea run.
Controls refuse rather than warn, and each names the function that enforces it. Audit-ready by default.
Generated Docker or macOS sandboxes: no network, only the worktree writable.
Staged secrets are blocked before a commit exists, and the line is named.
OpenSSF Scorecard and dependency review run in CI. Toolchain downloads are checked against digests pinned in the contract.
The MCP server exposes read-only commands. Each tool's exit code is its verdict.
Security modelReleases are deterministic tarballs with build attestations. Dependencies install only against pinned hashes.
Pin a tag, never main.
CLI, MCP server, hooks and every language pack: MIT, no agent limit. Plans price the dashboard and team features.
Free and open source. Download, run three commands, and every agent on the machine is governed.
See every agent, check and guard in one window (tour). Installing it puts thea and thea-mcp on PATH too, and Connect wires them into each agent.
A local app for what Thea recorded: agents, changes, checks. Private beta for Mac.
src/billing/invoice.pypython · format, types, testsPASSweb/app/routes.tstypescript · lint, typesFAILdb/migrations/0042.sqlsql · migration checkNOT RUNREADME.mdmarkdown · lintPASSEach page reads one Thea command or file. A failed source shows NOT RUN and the error.
git log and git statusthea verify --changed, run when edits pausethea resumethea failures: the failure ledgerthea model: the decision layer's judgmentsThe dashboard is a reader. Verdicts come from your toolchain through Thea, and they stay on your machine.
CLI, hooks, CI and dashboard read one verdict. Team sync is next: opt-in, verdicts only, never source.
Thea runs locally and writes only where you choose. No account, no telemetry, no Thea server.
Verdicts, ledgers and contracts live in your repository, under your own git history. The live agent count lives in ~/.thea/sessions on your machine: one small file per session holding the agent's name, its session id, its working directory and when it was last seen.
Never a prompt, a command, a diff or a file's content. Records unseen for a week are removed.
No telemetry, licence server or sign-in. Enforcement works offline, and the agent count never decides whether a check runs.
The test suite scans every shipped Python file for network imports. Only the modules below may make one; anywhere else, the suite fails before the change lands.
Everything Thea keeps is plain files in your repository and home directory. Team sharing, when it ships, will use storage you control.
Each runs only when you start it, with your own keys or remote, and talks only to the service you point it at.
It reads Python imports. Git commands go only to the remotes you configured. Your agents, editor and model providers keep their own policies.
No analytics, cookies, tracking or forms, and no web fonts. Live figures are read from the public README on GitHub, with jsDelivr as a fallback. Nothing you type or click is sent.
Policy for contract 3.52.0. Check it yourself: the scan is the case only the declared modules can open a network connection in the planted suite, and its source is on GitHub.
Pick where you work. Each path ends with a contract in your repository and checks that refuse unproven changes. Pinned to 3.52.0.
Turn on what you need. A gate skipped at the edit still stops the change later.
A chat that cannot run code still names gates, reviews a pasted diff and labels claims. Paste into project instructions.
Install, commands, MCP server, enforcement and controls. Every example comes from the repository.