Git tells you what changed. The decision log tells you why.

In July, a contractor posted on Hacker News about an agent that had created guest user records with empty name and email fields. The CTO found it in code review of a migration and asked why. The developer couldn't say: the discussion had happened in a Claude Code session, and Claude Code's default clean-up had already deleted the transcript, on two projects. The thread reached 44 comments, most of them about the same gap: the code was in Git, the reason for it was nowhere.

The Claude Code tracker has the same shape. One report, open since 28 July, says months of working context went with the 30-day clean-up and that the generated files (CLAUDE.md, plans, roadmaps) don't carry the reasoning the conversations did. Another describes hand-parsing session files with jq to recover a design discussion from before two compactions. And people are building the missing piece by hand: a "git why" that links task logs to commits, and a devlog the agent is made to write by a hook that won't let the session end until it does.

What Git keeps, and what it can't

Git is a log of the code: what changed, in which files, by whom, when. The commit message is whatever someone chose to write after the fact. The reason for the change, the option that was ruled out and why, all of that was said in the conversation with the agent, and the conversation is the one thing nothing keeps. It is compacted into a summary when the session gets long, and the file it lived in is deleted after 30 days by default (the setting that stops it is in Claude Code deleted your sessions?).

Axiom Lift is a log of the other thing: what you and your AI decided, kept in order, linked to the code it produced. Here is how that log is built, stage by stage, from the product's own documentation.

Stage 1: the conversation is kept

A small helper on your computer reads the session files Claude Code, Codex and OpenCode already write, read-only, and keeps a copy in your account. It has saved every line before a compaction and captures again at the moment of compaction, so the full conversation, including the part from before the summary, stays searchable. The tool's 30-day clean-up removes the file on disk; it doesn't touch the copy.

Stage 2: decisions are filed automatically

Nobody writes the log. As the AI works, when a turn settles something durable it files a short note: what kind of thing it is (a decision, a requirement, a correction, a discovery), the subject, a one-line summary, and evidence: pointers to the exact lines in the conversation where it was said. That is the short note you'll sometimes see at the end of a reply when something is decided. "Ok", "thanks" and "continue" are dropped before anything is filed.

Some facts need no model at all: commands run, tests that passed or failed, commits made and undo commands are read straight from the tool output. Sessions from before you installed can be labelled too; that is a paid job, done newest first, with a spending cap you set.

Stage 3: the log

Every filed item is one line in the log, and each line points back at the session, the turn and the words it came from. For any subject you see four kinds:

Stage 4: what happens when you change your mind

This is where a log differs from a notes file. In a notes file the old decision is overwritten. In Axiom it is retired.

1. You say it

   Three weeks after deciding on OIDC for enterprise sign-in, you tell the agent to keep SAML and drop OIDC. That sentence is in the session like any other.

2. It is filed as a correction

   The note for that turn is a correction, and it names the earlier decision it acts on. Axiom accepts the link only when a later statement acts on an earlier one.

3. The old decision is struck through

   The earlier line is marked no longer current, with the date it stopped holding. It is not deleted and keeps its link to the moment it was said, so "why did we ever choose OIDC?" still has an answer.

4. The next session gets the current line

   When Claude Code, Codex or OpenCode asks Axiom about sign-in, it gets the few lines that hold now, with what is no longer current listed separately, not the whole argument.

5. Any date can be asked

   The log is kept in order, so you can ask what was true on a given date and see it as it stood then.

Stage 5: linked to the code

Git is a sensor. The helper reports new commits and their files; the transcripts show the git commit and test commands the agent ran; GitHub, if you connect it, sends pull requests and checks. Each commit is matched to the decision or requirement it implements. When the link can't be made from structure alone, Axiom puts one small question in the next prompt and the AI answers it.

A commit that has landed and whose checks passed becomes verified evidence for the decision behind it. That is what lets you trace working code back through the evidence, the decision, the requirement that drove it, the AI that wrote it and the human who asked for it.

Is it really like Git?

In the ways that matter: a log, nothing ever erased, and you can ask what was true on any date. It tracks what you decided rather than the code, and links the two.

Claude, Codex and OpenCode are trademarks of their owners; Axiom works alongside them and is not affiliated.