Coding agents now write, refactor, and review code at human-equivalent rates. The next bottleneck isn't throughput — it's the context that never made it into the code. ASD records that context at the symbol level, in a sidecar that travels with the repo.
When an agent writes a function, the reasoning behind it lives everywhere except the code: a Slack thread, a PR description, the model's context window for exactly one session. None of that survives a rename, a file move, or the original author leaving. The next agent — or the next human — inherits the code and none of the decisions.
The diff alone doesn't answer what an agent already decided, what it's allowed to touch, or who approved it.
As more of a codebase is authored by agents, the gap widens. Agents are fast at producing code and blind to the accumulated intent around it. They re-derive decisions that were already settled, refactor patterns that were load-bearing, and touch code paths no one meant them to.
Each maps to a primitive that lives in the repo and is queryable from the CLI, MCP, and HTTP.
The reasoning behind a function evaporates between sessions. The next agent asks the same question you already answered and re-derives the same decision.
ASD remembers. A decision ledger attaches hazards, rationale, and constraints to each symbol — append-only, checked into git, surviving the rename and the file move.
Before an agent refactors, it needs the blast radius: disk, database, network — including transitively, through everything the symbol calls.
ASD propagates. 17 effect categories declared per symbol and pushed through the call graph, so effects_of returns the full set with provenance — declared vs. transitive.
An agent edited a file last week citing a policy nobody remembers. Did it hallucinate the rule? Nobody can check. The decision is orphaned.
ASD is auditable. Policy gates decide what needs sign-off; ratification attaches signed approvals; a hash-chained audit log records every mutation, replayable and verifiable.
ASD is a code-level overlay — the layer agents query before they read, write, or refactor. Linters check style; ASD records decisions. grep finds strings; ASD answers what does this touch, who decided this, was it approved.
The context has to travel with the code or it rots. ASD's committed sidecar lives in .asd/ and is checked into git, so every clone carries the same ledger, effects, and call graph. The live index is local; the human-authored subset is mirrored into tracked files by the sidecar. No server to stand up, no database to sync, no telemetry leaving your machine.