Coding Agent Findings Without Coordinates Are Just Hearsay
< BlogDeep Dives
November 18, 2026
13 minutes read

Coding Agent Findings Without Coordinates Are Just Hearsay

A coding agent can leave perfectly sensible advice without giving the next agent a reliable way to check it. Take this illustrative note from a debugging session:

Check role loading when login fails.

The agent had been investigating validate_session(). It had read the implementation, run a failing test, and traced the problem to missing role data. The note preserves its conclusion, but doesn’t identify the implementation it examined or the evidence behind it.

A second agent reaches the same function through an admin endpoint and records: “Authorization failures can originate in session initialization.” Both findings concern the same function. Whether they describe the same implementation, the same failure, or independent problems takes another investigation.

For a finding to travel between agents, it needs coordinates: a reference to the code element, the version examined, and the evidence supporting the claim. Without them, the next agent gets hearsay: a claim it can’t check without redoing the investigation.

I first made this argument in a talk at AI DevCon in Brooklyn; you can watch it on YouTube.

What Claude Code keeps

Claude Code memory illustrates how instructions and accumulated notes serve different purposes.

Project-level CLAUDE.md files provide persistent instructions and can be committed alongside the code. Auto memory stores Claude-written notes in a local directory, normally ~/.claude/projects/<project>/memory/. Its MEMORY.md index loads up to 200 lines or 25 KB at session start, whichever comes first; detailed topic files can be read later. That limit concerns startup context, not total memory storage. Anthropic documents the storage and loading behavior.

Auto memory isn’t intended to archive every investigation. The documented behavior excludes information recoverable from code, including debugging fixes, so Claude Code wouldn’t necessarily save our opening example on its own.

The broader issue applies wherever findings are retained: a session summary, a shared investigation document, or a separate memory system. Making the text available doesn’t establish which implementation supports it.

The person remembers what the note leaves out

For one engineer working on one repository, these omissions can be easy to overlook. You remember what “role loading” meant. You know which function the agent examined and whether the code has changed since. The note works because you supply the context it doesn’t record.

A colleague wasn’t there for that investigation. Neither were you, in any practical sense, when you’re reopening it four months later and can barely remember the bug.

The raw material may still be available, if anyone kept it. Claude Code records messages, tool calls, and results in session transcripts, but by default it deletes transcripts after 30 days. A test result or an edit can help reconstruct what happened. The difficulty is connecting a retained finding to the relevant parts of that record and to the code they concern.

Sharing the notes helps another agent discover them, but only a shared code reference lets a tool group findings about the same implementation even when one says “login” and another says “session initialization.”

Two findings, “Check role loading when login fails” and “Authorization failures can originate in session initialization”, shown twice: on the left both point to one validate_session() code element at source snapshot A; on the right each points to its own validate_session() record, one kept locally by Agent A and one by Agent B

Two findings can use different language for the same code. A shared reference makes that connection explicit; copying the notes into one folder doesn’t establish it by itself.

Five fixes that solve only part of the problem

There are five obvious ways to help a note like “check role loading” outlast the session that wrote it. Each fixes something, but each also leaves at least one of the three coordinates (the code element, the version examined, and the evidence behind it) unrecorded.

1) Share the memory folder

A synchronized location makes the notes accessible to other agents. Claude Code’s autoMemoryDirectory setting can select a different location, although synchronization itself needs to be arranged separately.

The contents still need interpretation. Making “check role loading” available everywhere doesn’t identify the function version or the test behind the advice.

2) Put findings in CLAUDE.md

Some findings deserve to become project guidance. A recurring constraint might justify a permanent instruction. But an expanding history of individual investigations is a different kind of material: each finding needs its own evidence and applicability checks.

Moving those findings into an instruction file doesn’t create those references. It also makes historical material compete with instructions needed for the current task.

3) Write a skill

A Claude Code skill can package a diagnostic procedure, reference material, or scripts, and can be invoked explicitly or selected by the agent. It could even run the tools that attach code references to findings.

Writing the procedure alone, however, doesn’t record which implementation was examined on each run. That association still has to be captured.

4) Add a commit hash

This is a meaningful improvement. A commit identifies a repository snapshot; combine it with a path and an unambiguous symbol reference, and tooling can locate the historical code. A commit alone doesn’t identify the function.

There are still questions to answer: did the agent inspect committed code or a modified working tree, and what should happen to the reference after the function moves? A recorded commit supplies part of the evidence and leaves both questions open.

5) Keep a wiki page for each function

A page can collect findings and their supporting material. A function name used as its only key becomes awkward after a rename, move, or split.

A wiki with structured references and maintained history can address this. The essential work is preserving the connection between the page and the changing code, regardless of where the page is stored.

None of these formats prevents a sound implementation. Markdown can hold structured fields just as a database can. The issue is whether the finding carries a reference that tools can resolve and check consistently.

When the code changes beneath the note

Return to validate_session(). In our illustrative timeline, an agent investigates role loading in March. Another investigates authorization failures in June. The function is rewritten in July. In September, a third agent reports that role loading is fine and recommends checking scope instead.

Those notes might disagree. They might describe different implementations or different conditions. Their dates alone don’t settle it: a September investigation could have used an older branch.

Findings from Agent A in March, Agent B in June and Agent C in September, each linked by dashed lines to both snapshot A and snapshot B of validate_session(), with a July rewrite between the two snapshots and a note that the code-version reference is missing

The notes record when the investigations happened, but don’t establish which implementation each agent examined. A later date doesn’t prove that the agent used the rewritten code.

An earlier finding might still be correct and its supporting evidence might also be available in a transcript or test log. But without the reference, checking that finding can mean reopening the investigation it was supposed to preserve.

Observability records can help, provided they include the relevant code references. Grouping runs by task, model, or session doesn’t establish that their findings concern the same function version.

What the missing layer needs

The missing information crosses three components: a code index that identifies elements, a version record that describes the inspected state, and a memory record that connects findings to both the code and their evidence.

Code references that different agents can agree on

A function name alone is rarely a sufficient identifier across repositories, files, and classes; a code index can supply a qualified reference. For independently running agents to compare findings, they need a common identity scheme and a consistent repository namespace.

Deterministic identifiers are one way to do this: the same normalized inputs produce the same identifier without agents having to negotiate each one. A shared registry could also assign identifiers. Determinism’s advantage is that independently running agents can produce compatible records without consulting one.

Git offers a familiar analogy through its content-addressed object storage. But a content hash identifies particular content; it doesn’t preserve a function’s logical identity after that content changes.

Versions that can be checked, with history across changes

The record needs to distinguish the function from the implementation examined. A repository revision supplies context for the investigation; a version or fingerprint of the function can help identify whether its own code changed. Uncommitted edits need to be accounted for too.

Renames, moves, and splits require additional handling. Some changes can be linked to an earlier element; others leave several plausible successors. The system needs to preserve that uncertainty rather than attach an old finding to whichever function has the most similar name. Even Git’s rename detection works on whole files and relies on a similarity threshold: by default, a deleted file and an added file count as a rename only when more than half of the content is unchanged.

A changed implementation is a reason to re-check a finding, and the finding may still hold. An unchanged function doesn’t guarantee that the finding still applies, either: callers, dependencies, configuration, or the conditions of a test may have changed.

Findings that carry references and supporting evidence

The capture tool should attach references to the code an observation concerns, using the files, symbols, edits, and test results involved in the investigation. It shouldn’t infer that every finding concerns whichever file happened to be open last.

A finding may concern several functions or a relationship between them. When the target can’t be resolved reliably, the record should say so.

A minimal record could look like this. These are illustrative fields:

FieldWhat it records
FindingThe observation or conclusion, in readable language
Code reference(s)The repository and resolved code element or elements
Observed versionThe code state examined, including relevant local changes
EvidenceReferences to the session, test result, trace, or edit supporting it

This keeps the explanation readable and gives software something concrete to compare. It also preserves the difference between an observed result and the agent’s interpretation of that result. Recording an identity doesn’t make the interpretation correct.

A code index supplies the resolved element validate_session() and a version record supplies the inspected state, snapshot A; both feed a memory record that stores the finding “Check role loading when login fails” with its code reference, observed version and evidence (session, test or trace), ready for comparison and re-checking

The three coordinates travel with the finding: the code reference from the code index, the observed version from the version record, and the evidence from the session.

What the next investigation should inherit

The next agent should be able to retrieve a finding from shared agent memory, locate the implementation it describes, and inspect the evidence behind it. That goes for agents working together, agents working weeks apart, and the same engineer returning to an old investigation.

When that implementation has changed, the record should make the change visible without pretending to know whether the finding has become invalid.

With code and version references, a query can gather findings about a particular implementation without first interpreting every note. That makes recurring investigations easier to inspect and gives reviewers a starting point for checking apparent disagreements.

More ambitious questions need yet more recorded relationships. To establish that:

  • a session repeated an earlier attempt, the record needs the attempted action and its outcome;
  • an earlier finding informed a later change, it needs a link to that change.

Matching function IDs won't answer either question on their own.

In the next post, we’ll examine how those references are created, how they’re checked as code changes, and how findings can be retrieved through them. The question to ask of a saved note is already pretty specific: can another agent identify the code and evidence it refers to without reconstructing the original session?

This is what it takes to connect what agents learn.

FAQ

Answers to the most common questions from this guide.

What does Claude Code’s auto memory save?

Four kinds of notes: your role and working preferences, corrections you give and choices you confirm, ongoing work and decisions that can’t be derived from the code, and pointers to outside resources such as an issue tracker. Claude skips anything it can derive from the codebase or that CLAUDE.md already says. The memory directory is machine-local, so other machines and cloud sessions don’t see it.

Where does Claude Code store session transcripts, and for how long?

Claude Code writes each session to a plaintext JSONL file under ~/.claude/projects/ on your machine, with every message, tool use, and result. For terminal sessions, a background sweep deletes transcripts older than 30 days unless you raise cleanupPeriodDays. Auto memory files are exempt from that sweep.

Doesn’t Git already track a function’s history?

Partly. git log -L :validate_session:auth.py traces how one function’s lines changed within a file, starting from a revision where the function exists, and rename detection follows a whole file to a new path when more than half of it is unchanged. Both work backwards from code you’ve already found. Neither gives the function an identifier that a saved finding can carry, which is what a later agent needs to match a March note to the code in front of it.

How is a function version different from a commit?

A commit identifies the state of the entire repository, so it changes with every edit anywhere in it. A function version, such as a hash of the function’s own code, changes only when that function’s code does. A finding that records both tells a later agent where to find the code that was examined and whether that function has changed since, however many unrelated commits came in between.

Related reading

Claude Code vs Codex vs Cursor: What Coding Agents Really Cost in 2026
Local AI Memory: Keeping Agent Memory Off the Cloud
5 Open-Source LLM & Agent Evaluation Tools in 2026
Get started

Cognee is the fastest way to start building reliable Al agent memory.

Latest
What Are 500+ Companies Actually Building with AI Memory?
Meet the new cognee: smarter memory, lower costs, and control for your team
Coding Agent Findings Without Coordinates Are Just Hearsay