Blog · ← All posts
Multi-Agent Attribution: Proving Which Agent Did It When Five Agents Share the Tools
By the Ingenious AI team · Published: November 14, 2026 · Reviewed: November 14, 2026 · 8 min read
The short answer: Multi-agent attribution fails when agents share identities, credentials, or a single undifferentiated log — and it is restored by three disciplines: every agent gets its own identity and its own hash-chained ledger stream; every cross-agent handoff records a caused_by link pinned to the exact record that triggered it; and incident analysis walks the resulting causal graph instead of interviewing logs. With those in place, 'which agent did this, on whose instruction, from what input' is a query, not an investigation.
Replay a recorded agent incident free → Step through a real recorded run in the replay view, or paste ledger records into the public verifier and get a VERIFIED/BROKEN verdict in seconds — no signup.
Single-agent systems have a forensic luxury: there is only one suspect. The moment a workflow grows a planner, two workers, a reviewer, and a tool-runner — all calling the same APIs with the same service account — that luxury evaporates. The CRM shows a change. Five agents could have made it. Their framework logs intermingle in one stream with one identity, and the postmortem opens with the worst sentence in incident work: we cannot tell which one did it.
Attribution is not a logging volume problem; it is an identity and linkage problem. This guide covers the three mechanisms that solve it in Agent Flight Recorder's design — per-agent identity, causal links between records, and cross-agent reconstruction — and the anti-patterns that destroy attribution even in systems that log heavily.
What is a causal link (caused_by)? a recorded relationship between two ledger records in which one agent's action was triggered by another agent's output: the acting agent's record names the exact record — agent, sequence number, hash — whose result it consumed. Chained across agents, caused_by links form a directed graph of the whole workflow's behavior, so any action can be traced back through its causes to the originating instruction.
Identity first: one agent, one key, one stream
Attribution begins at enrollment. Each agent receives a unique agent_id and its own API key, and its actions append to its own ledger stream. This sounds elementary and is violated constantly: frameworks default to a single integration key, teams copy it into every agent 'temporarily', and the temporary arrangement becomes the forensic architecture. When five agents write as one identity, no downstream cleverness can separate them — the information was never captured.
Keep identity meaningful as the fleet grows. Name agents for their role and environment (support-agent-prod, billing-agent-eu), version them when their mandate changes materially, and treat a new mandate as a new identity when the old one's history would confuse a future reader. An auditor reading 'research-agent' across two years should be reading about one job, not three.
The handoff is where attribution dies
Within one agent, sequence tells the story. Between agents, the story breaks at the handoff: agent A produces a result, agent B consumes it and acts, and B's records show an action whose true cause lives in A's stream. Without a link, B looks autonomous — and gets blamed or credited for A's decision. With a caused_by link, B's record names A's exact record, hash and all, and the chain of responsibility is continuous across the fleet.
Require the link at the framework level, not by agent goodwill: when a workflow engine passes work between agents, the receiving agent's first record of the task carries the causing record's reference. Retrofitting links from timestamps — 'B acted two seconds after A finished, probably related' — produces the word 'probably' in a postmortem, which is attribution failing politely.
Walking the graph in an incident
With identities and links in place, an incident query changes shape. Start at the harmful action's record. Follow caused_by backward: which record's output triggered this agent, and that one's cause, until the walk reaches a human instruction, an external event, or a scheduled trigger. Then walk forward along the same links to enumerate everything the root cause touched. The graph — rendered in AFR as a causality DAG across agents — turns both directions into minutes of inspection.
Pin findings to records as you walk: agent, sequence, hash. 'The planner's record 2,204 classified the ticket as a duplicate; the worker's record 891 cites 2,204 as its cause and closed the original' is a conclusion an engineer can recheck and a customer can be shown. The same conclusion from framework logs reads as an opinion about interleaved timestamps.
Shared tools are fine; shared stories are not
Agents will share tools — the same CRM, the same sender, the same payment API. Attribution survives sharing when each agent's call is recorded in its own stream with its own argument summary and the downstream identifier it received. The downstream system corroborates: the CRM's change history names the API key or session, and if that key is per-agent, the two records agree. If the key is shared, the downstream can only shrug in the same voice as your logs.
Rotate and scope keys per agent for the same reason: a leaked or misused key then has an owner, a blast radius, and an off switch that does not halt the whole fleet. Security and forensics are the same discipline here — both are the art of knowing which actor did what.
Attribution for the agents you do not run
Modern workflows call other people's agents and models: a vendor's support bot inside your product, a partner's enrichment agent in your pipeline. You cannot chain their ledgers, but you can record the boundary precisely — what your agent sent (digest and summary), what came back, when, and which of your agent's subsequent actions cited it as cause. When the vendor's system misbehaves, the boundary record is your evidence and your leverage; when yours does, it is also your exoneration test, because it shows exactly where foreign input entered your chain.
Contract for the rest: enterprise agreements with agent vendors increasingly specify the records the vendor keeps and produces on incident. A vendor who cannot produce a per-action record is telling you how your joint incident will go.
Five actions you must take today
Attribution is decided by architecture long before any incident. These five moves install it:
- Issue per-agent identities and keys. Every agent writes to its own ledger stream under its own credential; hunt down and retire every shared integration key.
- Make caused_by links mandatory at handoff. The receiving agent's first record for a task names the causing record — agent, sequence, hash — enforced by the workflow layer.
- Scope tool credentials per agent. Downstream systems should be able to corroborate which of your agents acted, from their own records.
- Record the boundary with external agents. What was sent, what returned, and which internal actions cite it as cause — digests where content is sensitive.
- Drill one cross-agent reconstruction. Pick a completed workflow and walk its causal graph end to end before an incident makes you learn the tooling under pressure.
Worked example: the ticket that two agents closed and none opened
At fictional SaaS firm Cadence Works, a customer's outage ticket was closed as 'duplicate' twice in one night while the real incident continued. Four agents touched the queue: a triage agent, a deduplication agent, a responder, and a summarizer. Each had its own ledger stream; the night's combined total was 8,317 records.
The walk took twenty minutes. The responder's record showed the closure action, caused_by the deduplication agent's record 1,462 — a duplicate classification. That record's own cause was the triage agent's summary record, which had merged two distinct tickets because they shared a customer and a keyword. The summarizer, initially suspected, never appeared in the causal chain for the closure at all — suspicion cleared by absence, the graph's other gift.
The fix landed on the triage agent's merging rule, the regression case was built from the exact records in the chain, and the customer response named the sequence — their ticket, the merge, the classification, the closure — with times and the fix. One agent erred; the graph proved which one, and just as importantly, which three did not.
FAQ
Why not just log everything into one shared stream with an agent field?
A shared stream with a disciplined agent field can work — if the field is set by the recording layer from the authenticated key, not self-reported by the agent, and if sequence within the stream still lets you order each agent's actions reliably. Separate streams per agent make both properties structural instead of conventional, and they let each agent's chain verify independently. The failure mode to avoid is the self-reported label on a shared identity: that is attribution by assertion.
How do caused_by links handle fan-out and fan-in?
An action can cite several causes (fan-in: the reviewer acted on three workers' outputs) and one record can cause many actions (fan-out: the planner dispatched five tasks). The graph is a DAG, not a chain, precisely to hold both shapes. Record every direct cause; the transitive story emerges from the walk, and sampling any path gives a complete lineage for the actions on it.
What if a human instructs an agent mid-workflow?
Record the instruction as an event in the agent's stream — who, what channel, the instruction summary — and let subsequent actions cite it as their cause where applicable. Human causes are first-class links in the graph; 'a person told it to' should be the most provable sentence in the incident file, not the least.
Can attribution survive an agent that spawns sub-agents dynamically?
Yes, if spawning is an enrollment act, not an improvisation: the spawner records a creation event naming the child's identity, mandate, and lifespan, and the child's stream opens with a caused_by link to that event. Ephemeral agents with unrecorded births are where attribution goes to die in modern frameworks; make the spawn API and the identity issuance the same call.
How does attribution help outside incidents?
Cost and quality accounting, mainly. Per-agent streams attribute token spend, error rates, and tool usage to the agent actually responsible, which turns fleet reviews from impressions into arithmetic. It also powers safe decommissioning: an agent whose causal footprint shows no downstream dependents for a quarter can be retired without fear; one quietly causing 400 actions a day in other agents' streams cannot.
Start logging your agents free → The free tier gives you the full hash-chained ledger for 1 agent and 1,000 actions a month, with chain verification and replay included.