A stale current-state line will send the next agent the wrong way
Public issues and posts show agents treating a written current state as truth after the facts have moved on. Point at a live source. Keep decisions and constraints in a place that lasts.
Public developer issues and discussions often come back to a written "current state" that the facts have already left behind. The line is still in the brief the next agent will read. The work has moved on. The agent treats the line as present tense.
The status line is still there. The facts are not.
In a public issue on eidolon, timlawrenz reported a drift review of the "Current state" section. It still said the z_g high-norm tail was open: the exp/zg-validity experiment had a gate approved, but had not yet been run. The tree already recorded that experiment as concluded on 24 September 2026, and a discontinuation notice explained the result. A "Next" line still pointed at Phase 5 of a fusion stack. That line predated a same-day rule that the GitHub board is the sole work queue, so an ungated "Next" line risks sending agents into Phase 5 GPU work.
The same kind of leftover shows up after a release. In gevechtspel2, version 0.5.20 had already shipped, but the standing brief still marked NET_VERSION 0.5.20 as unreleased. A handoff file still said steps 4 and 5 should go out in their own pull requests. Those pull requests, #295 and #296, were already merged.
These are not missing documents. They are snapshots that kept speaking in the present tense.
Agents will trust the line you forgot to update
That matters because the next reader is often an agent, and agents tend to trust what is written down.
waishnav described a pattern across several repositories. When asked to understand something in the codebase, Opus often reads the docs first and builds its picture around them. The docs are not always current. He has caught the model giving completely wrong explanations because it trusted an old Markdown file instead of looking at what the code does. He is considering two responses: stop maintaining in-repo docs, or tell the agent never to trust docs without checking the implementation. He is leaning toward the second, and is tempted by the first.
A preprint by Xiaonan Xu at the Georgia Institute of Technology and Wenjing Wu at the University of Colorado Boulder measured a related behaviour. In 40 small Python projects, the instruction file asked for one convention and the existing code used another. Claude Code and Codex CLI each added a feature, with and without a user-level sentence that told the agent to follow the existing code when the two disagreed, for 320 runs in total. Without that sentence, 90.1% of the agents' choices (649 of 720) followed the stale file, and only 4.2% followed the code. Claude Code named the conflict in 79 of 80 runs and still followed the file. Codex CLI rewrote existing code to match the file in 20 of 80 runs, and the project's original tests then failed in 17 of those runs.
The study used synthetic projects and two specific agent setups, in single unattended feature runs, with the instruction file outdated by construction. It is not a field survey of production repositories. It still shows the same tilt waishnav ran into: a written line often outranks the code, even when the agent has already noticed the disagreement.
Point at live state. Don't describe it.
The useful split is not "write more status" or "delete every document". It is to stop freezing a moving status in the brief the next agent will trust.
Replying to waishnav, Carlos Granier wrote that agents on his box used to start from a stale March inventory dump. He changed the setup. One file, behind both tool briefs, now has them run two commands first: the live task board and service health. As he put it, it points at state instead of describing it, and keeps status out of the document.
A similar move appears in a public issue on ECUST_AIgalgame. huaaaji reported that task status lived in a memory file and also in issues, pull requests, and git history. The copies drifted. In the local handoff for pull request #72, the top of the file still said the work was awaiting review, while a branch entry already recorded that review had passed. The proposed fix is to track current work in GitHub issues, and to keep the repository files for stable rules, contracts, and offline pointers.
A practical split looks like this.
- If it changes with the board, the release, or a health check, do not freeze it in the standing brief. Point at the live source. Let the next session query it.
- Decisions, constraints, and the reasons behind them change more slowly. Write those in a place the next session and the next tool will actually read.
- A written current-state line is a snapshot. When it disagrees with the code, the ledger, or the board, treat the live source as right, then update or remove the line.
- Telling the agent to verify against the code can help, but it does not replace a brief that has stopped speaking in the present tense about work that has already moved on.
MindMux itself makes a product in this space.
MindMux captures background, decisions, and constraints from the conversations you already have with agents, and writes them into a Markdown project brain. Agents read that brain over MCP before they start a task. To connect Claude Code or Codex, install @mindmux/cli and run mmx setup in the project. mmx setup --local gives a local Brain without Cloud login. The open, local counterpart, brain.md, is a brain/ folder in your repo plus a small CLI (@mindmux/brain-md). Structured Pages keep a compiled_truth, the current answer, and a timeline intended to preserve how you got there. Root documents are updated in place. It is git-native and agent-agnostic: Claude Code, Codex, Cursor, and anything else that can read a file.
This is cross-session, cross-tool decision memory. Status belongs in a live source. Decisions and constraints belong in the brain the next session will read. A stale current-state line should not be what sends the next agent the wrong way.