On 16 November I published an article about blocking the obvious ways a key reaches an AI coding agent. The first comment asked whether I had thought about putting blocked attempts on the conversation's timeline, with the agent's task and without the secret.
agentwhy already does that. The article gave it one sentence. So this is the start of a series: each week, one part of agentwhy, looked at closely. Part 1 is the view that answers that comment: what your AI and its helpers did, step by step.
All the screenshots are from the demo, a made-up project.
One conversation
You asked Claude Code: "Find out why the AI chat stopped answering." It worked for six minutes. The report's first screen answers in three lines.

The first screen of the report: one file it was allowed to read, two it tried to open and was stopped, one helper.
It read one private file you let it read, business-plan.md, which you set to Track. It tried to open two private files, customers.csv and .env, and a rule stopped both. It brought in one helper, and the helper read nothing private. Nothing to fix.
Who asked whom for what
How it went opens on a diagram. You asked your AI. Your AI read business-plan.md and was stopped at customers.csv. It also gave work to Helper 1, with the task "Find where the chat gets its AI key", and the helper was stopped at .env.

Orange is a read, dashed green is a stop, grey is "gave work to". The helper's task is written on its box.
The helper's task matters most to me. In my own incident in September, the rule in AGENTS.md never reached the helper. The helper only had its task, and the task asked for the secret. Here you can see the task that was handed down, word for word.
Step by step
The Step by step tab is the same conversation as a list, in the order it happened. Each stretch starts with what your AI wrote, then one row per step: what it read, what it ran, what it changed. Your AI's model sits above the list, as Claude Code recorded it: claude-opus-5-5.

Every step in order. The MCP step says plainly what the record can't show.
Two rows are worth a closer look.
The MCP tool. Your AI called search_issues on a Sentry MCP server. That server works outside the record, so agentwhy can't see which files it opened, and the row says so. It quotes the tool's own description, so you know what it was for.
The stopped attempt. "Tried to open customers.csv. A rule in your settings stopped it." In my setup a read refused by a deny rule fired no hook, so nothing in your hooks or logs would show it. It is still in the saved conversation, and that is where agentwhy reads it from.

A tracked read, a stopped attempt, and the handoff to Helper 1 with its task and model.
Then the handoff: "Gave work to Helper 1." The helper's row carries its job, in quotes, and its model. This one started on claude-haiku-5-5 and ended on claude-sonnet-5-5, so both are shown, with "The model changed while it worked."
Open the helper and you get its own steps, the same way.

Helper 1's own steps: it read assistant.ts, then tried .env and was stopped.
It read assistant.ts, then tried .env. A rule stopped it. So the helper did go for the key, as its task asked, and the block held. Without this view you would only know that .env was not read. With it you know who tried, and why.
Two switches help on a long conversation: Every step or Only private, to hide the rows that touched nothing private. And every row with a private file has What happened, which opens that file's own story.
Where it comes from
Claude Code saves every conversation as a file on your computer, and each helper's work in a file of its own. agentwhy reads those files, matches each helper's file to the task that started it, and puts them back in order. It runs on your computer, nothing leaves it, and any secret value is replaced before the page is built. It also works on conversations from before you installed it.
Under the hood
"Where it comes from" says agentwhy matches each helper's file to the task that started it. Here are two parts of that work, with the code. Every path below is in the public repository.
A helper's file, joined by its call's id
This part covers Claude Code alone.
Claude Code writes each conversation to a JSONL file, one JSON object per line. When your AI hands work to a helper, it calls the Agent tool, and that call is one line with an id. Here it is, with fake values:
{ "type": "assistant", "isSidechain": false, "message": { "content": [ { "type": "tool_use", "id": "toolu_01ABC...", "name": "Agent", "input": { "description": "...", "prompt": "...", "subagent_type": "..." } } ] } } The helper's own steps go to a separate file, subagents/agent-<id>.jsonl, in a folder named after the conversation. Next to it Claude Code writes a small agent-<id>.meta.json. These are the three keys agentwhy reads from it:
{ "agentType": "general-purpose", "toolUseId": "toolu_01ABC...", "spawnDepth": 1 } toolUseId is the id of the Agent call that started the helper. That is the whole join. A helper started another way, for example by a skill, has no toolUseId. In one session I found three of them. agentwhy reads the field as it is and never fills it in:
src/adapter/claude-code/events/delegation-index.ts
export function readDelegationIndex(text: string): ScannedIndexEntry | undefined { const meta = parseJsonObject(text); if (meta === undefined) return undefined; const callId = meta[META_FIELD.toolUseId]; const requestedType = meta[META_FIELD.agentType]; const depth = meta[META_FIELD.spawnDepth]; return { ...(typeof callId === 'string' ? { callId } : {}), ...(typeof requestedType === 'string' ? { requestedType } : {}), ...(typeof depth === 'number' ? { depth } : {}), }; } The core matches that callId to the Agent call with the same id. Where the ids do not pair one to one, it marks the link unresolved instead of choosing:
src/core/correlation/correlate.ts
const indexByCall = indexDelegations(records.delegationIndex, gaps); const delegated = new Set(records.delegations.map((call) => call.callId)); for (const entry of records.delegationIndex) { if (!delegated.has(entry.callId)) gaps.push({ kind: 'relation-unresolved', agentId: entry.agentId }); } // ... /** A second index entry for one call is the same kind of ambiguity: neither entry can be trusted to be the one. */ function indexDelegations( entries: readonly DelegationIndexEntry[], gaps: Gap[], ): Map<ToolUseId, DelegationIndexEntry | undefined> { const byCall = new Map<ToolUseId, DelegationIndexEntry | undefined>(); for (const entry of entries) { if (byCall.has(entry.callId)) { gaps.push({ kind: 'relation-unresolved', agentId: entry.agentId }); byCall.set(entry.callId, undefined); continue; } byCall.set(entry.callId, entry); } return byCall; } Why not by time? A helper can keep working after its call returns. In the session where I first measured the format, 6 of the 15 Agent calls returned at once, and the helper's report came later. A line's timestamp can also be earlier than the line before it. So agentwhy joins nothing by time. A link with no id is marked unresolved, and the delegation stays in the report.
A private file, known by its own lines
In the demo, Helper 1 asked for .env by name, so the record names the file. A command does not have to. A loop, a glob or a script can print a file's lines without naming it. In one of my own test projects, a report said Only saw a name over a file that nl -ba had printed.
agentwhy runs on the computer that holds the file, so it can check the output against it. Once per run it hashes the lines of every text file in the project. A line is a file's own when it has at least 20 characters, three letters in a row, and no other file in the project holds it. Only a private file keeps its hashes:
src/core/access/content-fingerprints.ts
add(text) { if (text.private) privatePaths.add(text.path); const lines = [...text.lines]; const own = new Set<string>(); for (const raw of lines) { const line = raw.trim(); if (line.length >= SHORTEST_LINE && WORDED.test(line)) own.add(hash(line)); } for (const key of own) holders.set(key, holders.has(key) ? null : text.path); // ... done() { const owners = new Map<string, string>(); const distinct = new Map<string, number>(); for (const [key, holder] of holders) { if (holder === null || !privatePaths.has(holder)) continue; owners.set(key, holder); distinct.set(holder, (distinct.get(holder) ?? 0) + 1); } Each hash is SHA-256 over a salt, the word text and the line. The salt is a new random UUID for every run:
src/composition-root.ts
const fingerprints = new ProjectFingerprints({ directories: files, files, salt: randomUUID() }); The hashes stay in memory. No line, hash or count of a file reaches a page, the chat or a store.
Then each line of a call's output, as the model got it, is hashed the same way, after the line numbers of Read, cat -n, nl or a search's path:12: are stripped. Two of a file's lines in one output are a read of that file. So is its only line, where it has one:
src/core/access/content-fingerprints.ts
filesShown(outputs: readonly string[]): readonly string[] { const hash = hashing(this.#salt); const found = new Map<string, Set<string>>(); for (const output of outputs) { for (const raw of output.split('\n')) { const key = hash(shownLine(raw)); const owner = this.#owners.get(key); if (owner === undefined) continue; const keys = found.get(owner) ?? new Set<string>(); keys.add(key); found.set(owner, keys); } } return [...found].filter(([owner, keys]) => keys.size >= Math.min(2, this.#distinct.get(owner) ?? 0)).map(([owner]) => owner).sort(); } // ... function hashing(salt: string): (line: string) => string { return (line) => createHash('sha256').update(`${salt}:text:${line}`).digest('hex'); } The limits. Only the project's own private files count, not ~/.ssh. A file over 512 KB is skipped, and so is every file once a project passes 20,000 files or 32 MB of text. Only whole lines match: a line cut short, encoded, or reprinted by a script (python3 printing a CSV's rows as dicts) does not. One line from a file with several is not enough, and a file changed since no longer matches. So this is second evidence. It adds a read and never takes one away.
When I built it, I compared the reports before and after on 286 of my own conversations: 185 in five test projects, 101 in agentwhy's own repository. Seven changed, each a read the command reader had missed. Nothing else changed.
What it doesn't show
- What the AI was thinking. Only what it wrote down and did. The page says so at the bottom.
- The order between helpers that worked at the same time.
- Which files an MCP tool opened.
- A rule ID, or a label that tells probing from one accidental glob. Five tries at the same file show as five steps, and you read the pattern yourself.
- The model, outside Claude Code. Codex and Copilot conversations get the steps, but Codex writes down less, and some of its steps leave no trace. The report says when it could not check fully.
Try it
npx @agentwhy/cli Run it in your project folder. It opens a page with your conversations from the last 7 days. Open one, then How it went, then Step by step. Or click through the demo first.
Next week, part 2: refusing the obvious reads, and which ones still get past.
What do you check first when you open a conversation your agent ran without you?
Disclosure: I build agentwhy, the open-source tool this post describes.

