AgentStateDeveloper is a code-level context and audit overlay for agent-authored code — a decision ledger, effect declarations, and a call graph for every function, all queryable by the agents that write the code.
Under the hood it's a git-native sidecar that travels with the repo: why a function exists, what it's allowed to touch, and who approved the last change — served over MCP. Rust core. 9 languages. Zero telemetry.
Set up AgentStateDeveloper for this repository. Run each step, then report back once asd is installed, this repo is indexed, and the MCP server is connected. 1. brew tap agentstatelabs/agentstatedeveloper && brew trust agentstatelabs/agentstatedeveloper && brew install asd — install the asd, asd-mcp, and asd-serve binaries 2. asd onboard — index the repo and register the MCP server (project-scoped)
brew tap agentstatelabs/agentstatedeveloper && brew trust agentstatelabs/agentstatedeveloper && brew install asd COPY ASD isn't a library you import — it's a sidecar that lives in .asd/, travels with every clone, and exposes the same graph to your shell, your coding agents, and the browser.
Everything the agents can do, you can do from a shell: index, read a symbol, query effects, append and ratify ledger entries, tail the audit log.
$ asd read payments.chargeCard $ asd effects_of processOrder
A stdio MCP server exposing 64 tools to Claude Code, Cursor, Codex, and Gemini — code search, call graph, effects, and ledger, right where the agent works.
$ asd onboard # registers MCP
An HTTP surface plus Lens — a browser view of the ledger, effects, call graph, and hash-chained audit trail for humans reviewing what agents decided.
$ asd-serve --port 7777 Each primitive answers a question an agent needs settled before it reads, writes, or refactors — exposed identically to your tools (MCP) and to you (the asd CLI).
Hazards, rationale, constraints, and authority — checked into git, surviving renames, file moves, and the original author leaving.
$ asd ledger get payments.chargeCard $ asd ledger append --kind hazard
A propagated 17-category effect set — io.fs.read, io.db.write, io.net.out — with each effect annotated by where it was declared.
$ asd effects_of processOrder Callers and callees for any symbol, so an agent can compute the blast radius before it changes a line.
$ asd callers_of billing.computeProration Declarative gates that decide whether a write requires approval — evaluated on every ledger mutation.
$ asd policy eval billing/* Signed approvals (ed25519) attached to ledger entries, so a decision carries its authority with it.
$ asd ledger approve payments.chargeCard A tamper-evident, hash-chained log of every ledger mutation and policy decision — replayable and independently verifiable.
$ asd audit tail --path billing/* These aren't hypotheticals — they're what happens to every team that lets agents touch real code.
Six months ago an agent introduced payments.chargeCard with an unusual retry pattern. Today it needs refactoring and no one can tell if the pattern is load-bearing or vestigial.
With ASD: asd ledger get payments.chargeCard returns hazards, rationale, and authority — the reasoning survived the rename, the file move, and the original author leaving.
An agent is about to refactor processOrder. Before it changes a line it needs to know: does this read disk? hit the database? call an external API — including transitively, through everything it calls?
With ASD: asd effects_of processOrder returns the propagated effect set, each annotated with where it was declared. The agent knows the blast radius before it commits.
A regression lands in production — billing off by 2% on enterprise plans. The team needs to know what changed, who changed it, who approved it, and what alternatives were considered.
With ASD: asd audit tail --path billing/* returns the hash-chained log of every mutation and policy decision in that subtree. Tamper-evident, replayable, verifiable.
asd-serve ships a web UI over the same index and audit overlay your agents query — the whole codebase as a stable map, per-symbol decision ledgers and verified effects, and effect blast radius, in the browser.
ASD knows what your code does — symbols, call graphs, effects, and ledger decisions. CTXone is the team layer: shared decisions, plans, and memory that travel across the whole team.
Wire ASD into the same Hub and your agents get both halves through one connection. Setup is one flag — installing either offers to set up the other. AgentStateGraph is the underlying state substrate.
ASD is the whole per-developer engine on your machine — all 64 MCP tools, the CLI, the HTTP and Lens UI, ledger, effects, call graph, policy, and audit. No account, no telemetry.
BSL 1.1 today; each version converts to Apache 2.0 after four years. Internal use — including production — is unrestricted; only offering ASD as a hosted service to third parties needs an agreement. Read the license →