The trust layer for the AI economy.

01The category

Chain of custody for AI-written work.

Every industry that relies on outside work has someone who checks it: auditors for accounts, inspectors for buildings, labs for medicine. Software never needed one, because people wrote it and people reviewed it. That stops being true when most of the code is written by AI, faster than any team can read.

TraceAxiom is building the missing role: an independent check that runs AI-written work before anyone relies on it, and a record of that check that travels with the work. We call it chain of custody for AI. It starts with pull requests.

• An independent check
• A record that travels with the work
• Starting with pull requests

02The problem

Making software got cheap. Trusting it did not.

Coding agents already write pull requests faster than people can read them, and they never stop. Today trust comes from a tired reviewer skimming a diff, or from another AI reading the same diff and offering its opinion.

An agent grading its own work is not evidence. A second agent's opinion is not evidence either. What settles whether a change does what it says is running it, with checks its author did not choose, and writing down the result where anyone can check it.

• Agents produce more than people can review
• Opinions about a diff are not evidence
• Running the change is

03Who it is for

Anyone who merges code they did not write and cannot fully read.

Engineering teams whose pull requests come from coding agents, and who need to merge faster without merging blind. Open-source maintainers flooded with AI-written contributions they never asked for. Platform and security teams who have to show what was checked before a change shipped. And, as the record grows, regulated industries that will need an audit trail for every line an AI wrote.

Verify serves the first two today. The rest follow as receipts become signed and the format becomes open.

• Teams merging agent-written code
• Open-source maintainers
• Platform and security teams
• Regulated industries, later

04The north star

A referee whose receipt travels with every piece of AI work.

TraceAxiom wants every change an AI makes to carry a receipt: the exact commits, the checks that ran, what each one found, the checks that did not run, and the verdict. A maintainer, a security team, an auditor or an insurer should be able to verify that receipt later, offline, without taking TraceAxiom's word for it.

The referee has to be neutral to be worth anything. TraceAxiom does not write the code it judges and does not sell a coding agent. The party that checks the work is never the party that did it, which is exactly why every agent maker can work with us.

• Exact commits, checks and verdict
• Verifiable later, offline
• Neutral to every agent

05What best means

Three things decide who wins this category.

First, the most accurate verdict: one that catches real bugs and rarely blocks good changes, with both rates measured on outside code and published with their error margins. A review bot cannot produce that number; a referee must. Second, the standard: a receipt format other tools issue and check, so a verified change means the same thing everywhere. Third, the default: Verify present wherever AI-written code arrives, without anyone having to choose it each time.

We will publish the first number only when it comes from real runs on other people's code. Until then the site says what is built, and nothing more.

• The most accurate verdict, measured and published
• The standard receipt format
• The default wherever AI code arrives

06Principles

Rules that hold at every stage.

Run, don't read: every verdict comes from what actually executed. Different minds check each other: independent tests are written by a model from a different family than the one that wrote the change, so the writer and the checker do not share blind spots. Say what was not checked: a check that did not run is never reported as passed. Open by default: the receipt format and its checker will be open source, so trust never depends on TraceAxiom alone. Consent first: nothing about anyone's code is published unless they installed Verify and agreed.

• Run, don't read
• Different models check each other
• Say what was not checked
• Open format, consent first

07Stage 1 · now

Verify: an inspection line at the end of every software factory.

The first product is Verify, a GitHub Action. It runs a pull request's own tests on the base and on the change, plants control tests so the results cannot be faked, breaks the changed lines on purpose to see whether the tests notice, checks what the pull request claims, and posts one verdict with its reasons.

It is in development. Since 3 October 2026 it posts its verdicts on pull requests in TraceAxiom's own repository. It is not installable yet; the waitlist is open, and design partners get it first.

• Being built now
• Verdicts on our own pull requests since 3 October 2026
• Not installable yet

08Stage 2 · next

Signed receipts, and tests the author never saw.

Next, each verdict gets a signed receipt that anyone can verify. For public repositories that uses GitHub's own artifact attestations; private repositories get an unsigned receipt until TraceAxiom's own signer exists.

Then independent tests: tests written from what the pull request says it does, by a model from a different family than the one that wrote the change. They must fail before the change and pass after it. A change's own tests miss some of its bugs, and tests written separately are the designed answer. They add evidence and never reject a change on their own.

• Signed receipts
• Independent tests from the stated intent
• Not built yet

09Stage 3 · later

Proof that merges, a standard anyone can use, and a referee agents can call.

Once the evidence is strong enough, low-risk changes should not wait in a queue at all: a change proven by every check that applies to it should merge on its own, while anything uncertain still goes to a person. The Verified Change Receipt format and an offline checker will be published as open source, so a verified change means the same thing wherever it was verified.

The referee also moves upstream. A hosted GitHub App will make installing a click instead of a workflow file, and a verify_change tool will let coding agents ask for a verdict themselves, before they ever open a pull request. Both are planned for early 2027.

• Low-risk changes merge on proof
• An open receipt format and checker
• A one-click GitHub App
• A tool agents call themselves

10Open records

Track records built from real outcomes, in public.

With permission, receipts become public verification reports, and reports become something the industry lacks: honest track records for coding agents, built from what actually happened on real code rather than from benchmarks. An open leaderboard of agents, ranked by verified outcomes.

Over time that record supports a guild of specialist agents, each with a public scorecard, promoted when its work holds up and demoted automatically when it does not. Nothing about a repository is ever published unless its owners installed Verify and agreed.

• Public reports, only with consent
• An agent leaderboard from verified outcomes
• Specialists with public scorecards

11The Workspace

Watch your own factory work, built only from real events.

The film on our home page is a sketch of something we intend to build for real: the Workspace, a live 3D view of a team's software factory. Every agent, every change on its way through, the check it is in right now, what that check found, and the receipt at the end.

It will be drawn only from real events, never from a simulation dressed up as one. When a change is waiting, you will see it waiting. When a check could not run, you will see where it stopped. A manager should be able to understand the state of an AI-built codebase at a glance, and click through to the evidence behind any part of it.

• A live view of every agent and change
• Built only from real events
• Every part clickable down to its evidence

12Beyond code

The same referee for any work an AI does.

Code comes first because it can be run. The same idea reaches much further: AI-written contracts and reports whose claims can be checked against their sources, AI-generated designs and data whose properties can be tested, AI decisions whose reasons can be audited. Truth: checking the claims in any AI output against something that can be tested. Record: track records for agents from what really happened. Assurance: standing behind verified work with warranties written alongside insurers, which only becomes possible once verdict error rates are measured and published.

These are long-term directions, not products. They will appear on this site as products only when they exist and have run.

• Truth: claim checks for any AI output
• Record: agent track records
• Assurance: warranties on verified work

13Focus

What we are deliberately not doing yet.

A vision this large is easy to dilute. So the order is fixed: no Workspace, no Truth, no Assurance until Verify's verdict quality has a public number behind it. No coding agent of our own, ever, because a referee cannot also be a player. No published figure, case study or customer name until it is real.

The vision is huge on purpose. The next six months are narrow on purpose.

• Verdict quality first
• Never a coding agent of our own
• No figure before it is real

14The company

Built to earn trust the slow way.

TraceAxiom is founded and led by Arhan Canli and built in the open. The ambition is to become the company the AI economy relies on to know what is true about its own work. The method is deliberately narrow: one check at a time, each one proven before it is claimed.

That is why this site follows the same rules as the product. Built means built. Everything else is labelled as a plan. A check that did not run is never reported as passed. The receipt format stays open, so trust in a verdict never depends on trusting TraceAxiom alone.

• Founder-led, built in the open
• Plans are labelled as plans
• Open format, consent first