#Changelog
Written per release, on the releases page — each one explains what changed and why, which is more use than a list of commits. The entries below are those notes in full, newest first: what was wrong, what it does now, and why the fix took that shape.
An entry that refers to the previous entry therefore points down the page, not up.
#Unreleased
#On Linux, the first run names Linux's folders
A first run on Linux that found no config listed ~/Library/Application Support/… for Claude Desktop, Cline, Roo Code and VS Code, folders a Linux machine does not have, though discovery already read ~/.config/… there. ambit connect used the same first path, so connecting one of them before it had a config created the macOS folder. Both now use ~/.config/… on Linux; macOS and Windows are unchanged.
#An agent can ask in the words it has
ambit can Bash answered no. The name resolved to the entry tool:bash, which carries no grant, while the gate asks about the same call as Shell Execution and puts it to the person. An agent that asked first was refused a call the gate would only have asked about, and learned to stop asking.
ambit can, and ambit_can over MCP, now take a tool by the name the runtime gives it: Bash, mcp__github__create_issue, or Bash(git push origin main), the form a Claude Code permission rule takes. The call is asked about as the gate asks, every capability it exercises is listed under asked_as, and the narrowest answer is the one given. An exact id such as tool:bash is still a question about that node, and where it has no grant the answer no longer suggests one on the entry, which no call would read: gate_asks names the capabilities a call through it is decided against.
Two facts go beside the answer and change nothing in it. runtime_rule is the Claude Code permission rule that names the call, when one does, so the graph's answer and the runtime's sit side by side. failed_recently counts the failures a runtime reported against those capabilities in the last week.
A sentence is offered what its words cover. ambit can "run the test suite" said no capability by that name exists; it now lists Automated Tests as a candidate, from the router ambit goal uses. It is offered and never chosen, and over MCP it is answered as a slip, so it files no deficit.
#A shell command that only reads is not put to the person
Every shell call was Shell Execution, acting, so with the gate on ls was put to the person because rm would be, and ambit can gave both the same answer. A command made only of programs that print what is already there (ls, cat, grep, git status, gh pr view) is now asked about as observing, as Read is, and the tree lets that run unasked.
Every other reading of a command can only add a question, and this one drops one, so it says yes only for what it can read whole. A redirection, a here-document, a variable set for the command, a program named by a path or a variable, sudo, xargs, find -exec, git -c and any word it does not know are acting. A refusal still reaches a read: cat a && op read … is denied as before.
#One question for a plan, a smaller answer, and a briefing for a task
ambit_can takes several calls in its capability argument, one to a line, and answers each as it would alone, cut down to the verdict, what it was decided against and why. A batch is a question about a plan, so it files no deficit. Over MCP an answer no longer carries keys that say nothing: a grant with no holder, scope, note, expiry or condition sent five of them every time.
ambit_briefing takes a task, and ambit briefing --task="…" the same: for the capabilities the goal router says the sentence touches, whether each is reached, what its last check said, whether acting on it is allowed, and which providers to reach for. It moves no mark.
ambit goal names those providers too. A capability already reached said so and stopped; it now lists what supplies it here under use, those a check has passed first, leaving out any whose last check failed.
#A check says what it ran
ambit verify reports the command beside the result, as ran. "Verified" for Version Control means git --version exited 0, and the word alone read as more than that.
#The briefing says what was never checked
The first line counted what is verified. On a graph where no check has run it now adds how many reached capabilities carry a check, names three, and points at ambit_verify, since an agent reads reached as working.
#A dead connection is named
ambit doctor looked for a server entry called ambit. One written by hand under another name, pointing at a checkout since moved, read as not connected, and the advice was ambit connect, which adds a second entry and leaves the dead one failing at the start of every session. It now finds an entry that starts Ambit under any name, says which path is gone, and counts a runtime as connected only when an entry there can start.
#Help that answers what it is asked
ambit help graph lists the graph's views and says ambit help <verb> shows one in full, but ambit help graph surface printed the same list again, and ambit help surface searched the glossary and answered with Recovering, whose text says "surface". The graph entry and its options were reachable only from --all. A view, asked about on its own or after graph, now prints that entry and the view's own, and ambit surface is offered ambit graph surface, the one place a view runs.
The map's help had three claims the page no longer kept. Reading the map gave each kind of entry a colour and a glyph that only the retired domain-column map drew, where the tree colours a circle by its state; it now says what a failing circle and a recovering one look like. Shortcuts said every key works anywhere on the page, and the map's keys (J and K, the lenses, the zoom) do nothing on My Setup or Audit; they are listed apart, under On the map. Start here sent a first visitor to ambit status for "the next steps", which it does not list; it now names ambit, as the CLI's own help does.
#0.7.1 — 2026-11-10
Ambit on Windows, and a container image that starts.
#The container image starts
The image's last stage copied the compiled CLI without its dependencies, so node cli.js mcp stopped at once with Cannot find package '@modelcontextprotocol/sdk'. The stage now installs the production dependencies.
#Windows
Ambit found no config on Windows and wrote its graph under the current directory, because Windows sets USERPROFILE and no HOME. It now takes the home directory from either, in the CLI and in the plugins that transcribe the spool's path, and reads the six runtimes that keep their file under %APPDATA% there. A check written for sh on a machine with no sh stays unverified, since it could not ask: counting that as a failure would have dropped working capabilities from every plan. A new CI job runs the CLI on Windows against a throwaway home.
./bootstrap.sh does not run there, and ambit weigh cannot start a server launched through a .cmd such as npx, since doing so needs a shell and it starts servers with none.
#What went away
ambit graph export no longer writes a position on each node. It held zeros left over from the 3D map, and nothing read it. scripts/adapters/claude-code.ts is gone too: ambit seed reads Claude Code itself, so the script's --seed repeated it, and printing what an install provides without writing it has no command now.
#0.7.0 — 2026-11-04
The release that gives a newcomer one answer wherever they start, and measures more of what an agent setup costs. In short:
- One readout, wherever you start. The hosted demo,
npx ambit-cli,ambit weband the Claude Code plugin now state the same reach and the same next steps for the same setup, and a test holds the tab and the terminal to it. The demo asks for your setup on its first card, not its fifth. ambit weighmeasures what each local tool server's tool list costs in context every session, per runtime.- More of the spend, measured. Tokens from Codex, OpenCode and Amp are read from the logs those agents keep, Claude Code's as a session runs, and
ambit usage --windowsreports them in five-hour windows.ambit connect cursor --ledgerfeeds Cursor into the work ledger. - More of the machine, read. Copilot CLI, Amp, Goose, Kiro and VS Code's own MCP servers join the runtimes Ambit reads, with the models Ollama and LM Studio keep on disk.
- An approved change reaches the runtime you use.
ambit apply <id> --to=claude-codewrites that runtime's config andambit rollbackgives the file its bytes back; where it cannot write, it prints that runtime's own command. - The latest check decides. One passing check brings a capability back into every plan, where it took five in a row, and it reads as recovering until its recent runs pass.
- A first session that starts small.
ambit helplists the eight commands a first session uses, and--helpafter any command says what it does and runs nothing. It used to run it, soambit verify --helpran every check andambit approve <id> --helpapproved. - Control plane. An opt-in Docker adapter runs an approved step's command in a throwaway container with no network and no host mount by default.
- Three fixes to what may reach you. The API server refuses a page on another local port, where any page on
localhostused to pass.ambit applywrites a step's patch only when it is the shipped tree's, so an overlay in a cloned repository cannot give a step its own command. A service that stops answering stops counting as reached.
#A Node too old for Ambit says so
The package declares Node 22.18 or newer, and on anything older npx ambit-cli died on a flag or a missing module with nothing saying why. It now names the version it found and the one it needs. The status line and the gate stay silent on an old Node, since neither may clutter a screen or block work. The first screen also names ambit share, and the demo's paste box says it needs only the server names.
#What was missing says so where you already look
A grant of forbidden printed success and ambit can answered DENY, and nothing said that a tool call only stops once the gate is on. ambit authority grant and ambit budget set now say so when it is off, ambit doctor lists it, and ambit connect claude-code --gate adds the hook where the plugin is not used.
Bare ambit and ambit status never named connecting the agents or recording them, though the ledger's reports are empty until both are done. Each now names the next missing step for the runtimes found here, and ambit connect ends on what is still missing where it used to end on the runtimes it did not find. ambit doctor also counted a Claude Code install with the plugin as not connected, and no longer does.
ambit repo, which recommends what to add for the project in the current folder, was listed in ambit help plan and nowhere else. Bare ambit now says what it would suggest when run inside a project, and it joins the first-session help, the README and the plugin's skill.
#Help that starts small, and --help that runs nothing
ambit help was meant to cover a first session and listed seventeen commands with their options, --judge[=url] and goal --spec among them. It now lists the eight a first session uses, in the order a person meets them, and the five groups with a line each. ambit plan printed the group's whole section of --all, sixty lines of which the judge's options were most; each group now prints one line a command, and ambit help <command> shows that command's entry in full with the word it rests on (ambit help verify ends on Verified). ambit help verify used to explain the word and never the command, and ambit help frontier printed Ambit's entry first because its text mentions the frontier: a word that names a concept now shows that concept alone, and a slip is offered what it was probably meant to be.
--help after a command was one more flag the command ignored, so ambit verify --help ran every declared check, ambit approve <id> --help approved, ambit mcp --help started a server waiting on stdin, and ambit web --help opened the map. --help and -h anywhere after a command now print its entry and run nothing. Help no longer opens the graph, so it no longer waits on the spools and session logs, or creates a graph on a fresh machine. Bare ambit graph on a terminal prints its group's index where it printed a hundred kilobytes of JSON on one line; a pipe and --json still get the export.
#One reach, one step, said the same way everywhere
Bare ambit said "9 of 46 capabilities" where ambit status, the agent's briefing, ambit doctor and My Setup's journey said "18 of 55" of the same setup. The larger figure counts the person's own servers, models and runtimes as well, and both are true. Every sentence that states reach now holds both, "9 of 46 capabilities reached, and 9 of your own", so each agrees with the other surfaces and the evidence rows under ambit status still add up. The page's Time & cost and journey count the tree, as the map does, and ambit_stats carries the sentence for an agent to quote.
The map lit what a step would make reachable eventually, taking each next step it opened as reached and going on past it. So Hosting lit Launch Ready, three steps away, beside a sentence naming the three next steps on the way. What a step brings is now one rule in src/shared/nextSteps.ts, the capabilities reached with it and the next steps that leaves, which the map lights, the finding counts, the banner and the panel state, and the readout names. On the demo, Embeddings opens two where the map said four.
A frame on the map may zoom out to fit what is lit, and now zooms back to the person's own zoom for the next thing lit and when the simulation ends. It used to keep the smaller zoom the previous frame chose, so an unlock after a selection drew its names at eight pixels. On a phone an outage keeps its root's callout in frame, and a sheet open on the simulated node takes the banner's place, which repeated its sentence in three lines over the era names. npm run shots photographs an unlock after a zoom by hand and an outage rooted in the first column, and flags a banner over an era name and a callout off the map. The hero recording holds its ten-pixel floor in every beat that is read, and ends a simulation by the button's real name, which it had been missing, so its selection beat no longer showed the unlock still running.
The concurrency test ran its "concurrent" writers one after another, and a writer that failed said nothing of why. They now hold the lock against each other and report their stderr. The status line's half-second budget scales with the machine's load, so a saturated machine no longer fails it.
#An approved change reaches the runtime you use
The tour ends on "Agents propose changes… Only you can approve one", and for most people approving was the end of it. ambit apply wrote OpenCode's config and nothing else, so a Claude Code or Cursor user who approved a change had no command that made it. It now writes the runtime --to names, by the word ambit connect takes, or, without one, the one runtime whose config is on the machine: ambit apply <id> --to=claude-code puts the server under mcpServers in ~/.claude.json, keeping the rest of the file, and ambit rollback gives the file its bytes back. The re-seed after either reads every runtime, where it read OpenCode alone and left what it had just written unseen.
Where it cannot write, it says how to make the change by hand instead of refusing with nothing: several runtimes and none named, Codex's TOML, a file that is not there. Each runtime gets its own command where it ships one (claude mcp add --scope user …, codex mcp add …, code --add-mcp …), each checked against that CLI's help, and otherwise its file and the entry. --print asks for that on purpose.
A plan reads its ways to acquire a capability from the tree with any project overlay merged in, so an overlay, which can arrive with a cloned repository, could give a step its own command and apply would write it once someone approved. A patch is now written only when it is the shipped tree's.
#Every view, as a screenshot
Each view was photographed at rest at 1440×900, 1280×720 and a phone, and fourteen things were wrong with the pictures.
The map framed what it lit flush left, so the outage cut the Tool Use column and the callout on its own root, and the first local visit sliced a column at the left with empty canvas by the card. Opening a node's panel left a column cut at the panel's edge. A phone opened on two columns and most of a third. Now, beside a panel or a card, the map shows the whole tree when it fits there at half size, since a frame of all of it cuts nothing, and otherwise starts on a whole column. A phone opens on three whole columns, at 0.77 where it was 0.72, and the readout puts the map's controls away there as the tour does. At rest, a tree shorter than the canvas is centred between the controls and the key.
The demo's "worth $9,600" said "sample" only in a closed toggle under it, and a phone dropped the Sample tag; the label now sits on the figure and the tag stays. Every lazily loaded view said "Loading the map…", and one whose code failed to load spun forever; each now names itself and offers Reload. At 1280px the header's status pill wrapped onto a second line, and it now folds its bar, then its last count, into the tooltip. The grant ladder shared the era ladder's class names and was squeezed into "Unattendec". A command broke mid-id on a phone.
Audit and My Setup open on a sentence about what follows: how many events and what came of them, and how the checks stand. The council shows each seat's command where five buttons said "Copy the command". A proposal leads with its title, not its id. The welcome screen shows the sample's next step lit beside the hero on a wide screen.
npm run shots takes the same pictures, flags the faults a machine can see, and writes a contact sheet.
Re-recording the README's images found three more. A simulation's banner sits a row under the map's controls, and on a canvas scrolled to its top it lay over the era names, which are buttons; the canvas now starts below it, as it does below the headline. The callout on an outage's root reaches left of its column, and a frame flush to the first column cut "DOWN ·" off Shell Execution; the frame keeps it. The agent-loop recording read the recording machine's local models, so on one holding an embedding model there was nothing to propose and it stopped, and its history showed that machine's counts. It reads only its fixture now, and shows each MCP answer a field to a line, where it printed one line of run-together JSON.
#One readout of your own setup, wherever you start
A newcomer meets Ambit in one of four places: the hosted demo, npx ambit-cli, ambit web or the Claude Code plugin. They said different things about the same setup, or nothing. Three servers pasted into the demo reached "9 of 46" with Local Runtime next, and npx ambit-cli on the machine they came from said "18 of 55" with Hosting next. The page ranked by how far a step would let the tree reach eventually, the engine by blocked work and then leverage per hour, and the terminal counted the person's own servers as capabilities. The ranking now lives in src/shared/nextSteps.ts, which both read; the readout measures the curated tree, as the map does; and a test reads three configs both ways and holds them to the same reach and the same next steps, in the same words.
The demo asks for your setup on its first card. It used to be the fifth, after four about a stranger's setup. The sample's next step still lights first, and the outage, the failing check and the approval follow for whoever asks. The intake asks which agent you use before anything else, since that decides the model a setup is placed with and the file to paste, whose path it offers to copy. Codex keeps TOML, which the tab cannot read, so for Codex it offers the servers to tick.
npx ambit-cli ends on one thing to do and writes each command the way Ambit was run: npx ambit-cli web, where it said ambit web, a command an npx user does not have. ./bootstrap.sh prints the same readout. The first visit to ambit web opens on the map with the readout over it and the engine's next step lit, where a card used to explain the map's controls, and My Setup's seven-step journey moved to the end of the entries. In Claude Code, /ambit shows the readout. A phone fits everything a simulation lights, and the map measures a card in its corner and scrolls its last columns out from under it. The API, the page and a checkout without the map's dependencies no longer send people to ./bootstrap.sh, or to clone the repository they are in.
#The Proposals tab's count reaches a screen reader
The tab's label is fixed at "Proposals" so it still names the tab where only the icon shows, and a label replaces everything inside the button: the badge with the number of drafts waiting was never read out. The count is now the tab's description, "2 waiting for your decision", and the badge itself is hidden from assistive technology so it is not read twice. The name stays the word on screen, which is what a voice command says.
#The page and the landing docs, read as a newcomer would
A pass over every string the page shows and over the README and the docs a search lands on, for the same two faults the last copy fix found in a dozen places. The first was the engine's own words used as if a reader knew them: "observation", "the ledger", "bridges", "tending", "an act", "the trail", a function name. Each now says what happened and what to do; a past moment of the map is a moment, Time & cost's empty page gives the Claude Code plugin's install commands beside OpenCode's, and the Audit view off a machine says to run ambit web. The second was text describing what the screen already shows, or saying one thing twice: the briefing tab listed the briefing printed under it, a repository row explained its own drift badge, a turned-down proposal said "Turned down" under a pill saying the same.
Errors say what was refused and what to do instead: a paste too large names the 2 MB limit, and one that is not a config says what shape would be. The approval reason box asks for a reason, not "Why not?".
Three things were wrong, not just unclear. The docs counted twelve runtimes when sixteen are read. The config-locations page sent readers to a Repos tab that is the Environment section. The audit guide said nothing leaves the machine, which a declared check that fetches a URL contradicts; it now points to the FAQ's list of every command that can.
#One name for each command, one meaning for each flag, one default window
Every old spelling still runs; help teaches the one below.
- One name per command.
brief,digestandrulesarebriefing,attentionandinit-rules. A command and its singular are one command:proposals <id>,opportunities <id>andincidents resolve <svc> <outcome>replaceproposal,opportunityandincident, andnotify <topic> --approvalsreplacesnotify-approvals. The aliases live in one table insrc/engine/cli/groups.ts, so the switch, the help and the typo suggestions all know the canonical name alone. ambit checklists its group, as every other group does. It ran the doctor, under a name that also meant the CI check, which isambit ci.--byalways names a person.approveandrejecttake--by=<person>as every other decision does, and the trailing name they took before still works; with neither, the decision is the one person the graph knows, so on a machine with one person nobody types their own name into every decision. A mistyped name is refused, never read as a second proposal. The ranking of opportunities is--rank=, andrecordnames a runtime with--runtime=;--bystill means each there.- One default window. Every report over the ledger looks back 30 days unless told otherwise (
DEFAULT_WINDOW_DAYS), and takes--days=Nas well as the bare number:attentionandauditlooked back 7, soambit attentionand the Time & cost page read the same ledger over different months. ROI keeps 60 days before and after, a receipt the last hour,usage --windowsthe last day, andnotifya week, since a phone told about a month at a time is told too late.
#The first ten minutes, read the way they were meant
A walk through the commands a new user types, from a fresh home, turned up five places the CLI made them do the work:
- A typo names what it was meant to be.
ambit stautsanswers "Did you mean ambit status?", and a word near nothing still points toambit help. - One reading of a capability's name.
impact,verify,verify --history,authority grantandpromote, andbudget setandclearnow read a bare name the wayambit can, every MCP tool and the gate already did:githubwas refused by one, prefixed intocombo:githubby another, and answered "Nothing to report" by a third. A near miss is a suggestion, never a guess.ambit verify githubnames the checks on what the server provides, since a server runs none of its own. ambit nextreads as steps. Each with its time and why, then the two commands that act on it, in place of nested records keyed bycombo:ids.- The note on recording what blocks work names your runtime. It sent everyone to copy the OpenCode plugin; it now names the Claude Code plugin,
ambit connect cursor --ledgeror the OpenCode plugin, for the runtimes the seed read. ambit doctorgrades what a person can act on. A fresh setup was graded F (5/100) before any check had run, and one whose every check passed still scored under 30, because the score counted the share of the whole tree reached, nodes no check can prove, and the built-in tools every runtime holds alone. It now waits for evidence before grading, gives 60 points for proven out of what can be proven, 30 for redundancy among servers and models, 10 for Ambit being connected, and takes 15 off per failing check; its advice prints one step per line and no longer asks someone who just ran every check to run them again.
#The briefing says what the next step would let you reach
A next step told the agent what it cost and, when work had been blocked on it, only that: "It has blocked work 4 times." What reaching it would bring was dropped whenever blocked work led, so the step that mattered most said least about what it would open. Each next step now carries reaches, everything something here already supplies that reaching it lets the frontier reach, through every hop, by the simulation ambit goal --simulate and ambit_simulate run, and opens, what it would make a next step. why keeps both beside the blocked count, and the briefing says them to the agent in its own terms: "Embeddings (10m): With it, Vector Store and Local Embeddings would become next steps."
#A capability failing its own check is no longer counted as unblocked
The simulation behind goal --simulate, proposals' previews and now the briefing admitted any supplied capability whose prerequisites were met, failing or not, so a configured capability failing its own check was reported as unblocked by every simulation, one that assumed nothing included. On the demo's setup, every next step claimed it would bring back Browser Automation. No acquisition brings back a check that fails; a pass does, and the simulation and the next-step ranking now leave it out until then.
#ambit weigh measures what each tool server costs in context
A runtime puts every tool server's whole tool list into the model's context at the start of each session, called or not, and nothing said how much that was. ambit weigh starts each local server the user-level configs declare, asks for its tools over MCP, records the list's size in tokens and stops the server. The report is per runtime, since each carries its own servers, lists each server heaviest first with its heaviest tools, and, once the ledger has recorded calls, names the servers carried into every session and never called in thirty days. My Setup prints each server's figure and each runtime's total under the new glossary term Carry weight, and a server's panel says the same. Because a server is a command, this is the only time Ambit starts something a config declares, and it does so only when typed: never from the server, never from a project's committed config, and never for a remote server. SECURITY.md and AGENTS.md state the exception and its limits.
#The loadout as pilot and machine
The docs drew on four families of metaphor at once. docs/loadout.md now holds one. The loadout is the machine and you are its pilot. The map, My Setup and Proposals are the hangar; the briefing, ambit_can and the gate are the cockpit; and the frontier reads as a flight envelope. The section was called "Stepping in", which the attention ledger also uses for a person intervening, so it is "Pilot and machine" now.
#Three merged pull requests that never reached main
Pull requests #97, #98 and #99 were each merged into a branch that had itself already been merged into main, so their work was reviewed, merged and never released: the status line, the Docker executor, goal --spec, session-log tokens, the four new runtimes, local models from disk, five-hour usage windows. The entries below are theirs, as written then, and land now. scripts/check-reach.ts is what would have caught it, and runs in CI from here on: it fails a pull request whose base is not on its way to main, and on each push to main and once a day it fails if a merged one never got there. The push is the moment that matters, since it is when the bottom of a stack merges and the next pull request up is left pointing at a branch nothing will merge again.
#Usage in five-hour windows, as it happens
Claude Code's token counts arrived only when a session ended, from its transcript, so a long session counted for nothing until it closed, and every agent's tokens were kept as one total per session, so no one could say how much the last few hours had used. Claude Code transcripts are now read as they grow, with or without the plugin, and every agent's tokens are kept per hour. ambit usage --windows (and ambit_usage with windows) reports the five-hour windows Claude Code and Codex plans reset in, counted as ccusage's blocks count them: tokens per model, the cost where a price is declared, and the time left in the current one. Time & cost shows the current window beside the month. Ambit knows no plan's limit, so it shows none, and no share of one. Only counts, model names, message ids and times are read from a transcript, and AMBIT_NO_LEDGER=1 stops the reading.
#An approval names the command, and the control plane can run one
The control plane gains a real environment adapter, chosen only by AMBIT_ADAPTER=docker or --adapter=docker: an approved step's command runs in a throwaway container with no network, no image pull, a read-only root, no Linux capabilities, an unprivileged user, resource limits, and no host mount but a named working directory, read-only. A step reaches the network only through a grant for the network action on its capability. When Docker cannot run the step the control plane refuses, and never falls back to the simulator; every span names its adapter.
Running something real exposed two gaps the simulator had hidden. An approval named a proposal and its capability, not the command, so whoever held one chose what ran: a blocked call's command is now written into the step the person signs, and a retry carrying any other command is refused. And break-glass, the agent's own say-so, could stand in for a person and outrank a forbidden grant: it never outranks a refusal now, and with the Docker adapter it runs nothing at all.
#A status line, and a faster gate
ambit statusline is a line for Claude Code's status bar: what is failing, what is waiting on you, and how much is verified, in at most 60 characters, nothing when there is nothing to say. It opens the graph read-only and writes nothing, and answers in about 45 ms on an installed copy. ambit connect claude-code --statusline sets it where no status line is set and never replaces one; the README shows how to print it beside a status line you already have.
ambit gate runs before every Claude Code tool call, and the wrapper started the whole engine to answer it. It now answers in its own process, as the status line does: about 120 ms a call on an installed copy, down from about 180, with the same answer byte for byte.
#What a spec needs
ambit goal --spec <dir|tasks.md> reads a Spec Kit feature (its tasks.md, and the plan's dependencies, storage and testing) or an OpenSpec change, routes each task the way ambit goal routes a sentence, and reports the capabilities the spec needs, which are reached, what stands in the way and how long closing it takes, and the tasks that route nowhere. The spec is read as data: only markdown is opened, code blocks and links are dropped, and nothing in it runs. ambit_goal takes the same as an optional spec.
ambit goal also stopped matching a goal phrase inside a word: "rag" matched "coverage", "ship" matched "relationship" and "ci" matched "specific". A phrase now has to start a word, and "deploy" still matches "deployment".
#Tokens from Codex, OpenCode and Amp, with nothing installed
Only Claude Code sessions reached the spend meter. Ambit now reads the session logs Codex, OpenCode and Amp already keep, the same records ccusage reports from: each session's id, model names, times and token counts, never what a session said or ran. Each session is one run, counted once however often its log is read, and a read that finds nothing new costs a stat per file. Time & cost names which agent each count came from, and a declared price makes those tokens a spend on Hosted Inference. Tokens from before a budget's current period are priced and not spent against it, so a first read of months of history cannot use up this month. ambit usage --refresh rereads every log, and AMBIT_NO_LEDGER=1 stops the reading.
#Copilot CLI, Amp, Goose and Kiro
Discovery reads four more runtimes, each from the location its own documentation gives: Copilot CLI's ~/.copilot/mcp-config.json, Amp's ~/.config/amp/settings.json (under the one dotted key amp.mcpServers), Goose's ~/.config/goose/config.yaml (its extensions, read by a small reader for the documented shape; the secrets under envs are left behind), and Kiro's ~/.kiro/settings/mcp.json. ambit connect can register Ambit in Kiro, whose file has Cursor's shape; the other three would each need a writer of their own. ambit doctor kept its own list of runtimes and knew seven of them; it now takes them from discovery, so it sees all sixteen and reads whether Ambit is connected in each file's own shape.
#Local models, from disk
Discovery lists the models Ollama and LM Studio keep on disk, by folder and file name only: no model file is opened and no model server is asked, so seeding still opens no socket. They reach Local Runtime, Local Tool Calling, Extended Context and Local Embeddings, never Hosted Inference, and are never priced as hosted. Two patterns that read the new names wrongly were fixed: an embedding model such as qwen3-embedding no longer counts as a model that calls tools, and bge-m3, all-minilm and bge-small reach Local Embeddings.
#The servers most people install, recognised
A filesystem MCP server now provides File Editing, and the agent memory tools (claude-mem, cognee, Letta, Graphiti) Persistent Memory; mem0 and anything named memory already did. A test holds the curated tree to the servers most developers install, keyed as their own READMEs key them. Context7, Notion, Figma and Sequential Thinking reach only Tool Protocol, since the tree models nothing they provide.
#Your own config, placed on the map in the demo
The demo's tour ends on "Now map yours", and a pasted config used to end on a list of its entries and a note that placing them on the map took the engine, so the question the tour had just raised, what one more step would open, went unanswered for the setup the visitor cared about. The page now places a pasted config on the curated tree in the tab, by the same rule the engine seeds with (placeOnTree in src/shared/placement.ts, which seedTechTree now calls too), and a test holds the two placements equal. A card says how much of the tree the setup reaches and offers the three next steps that open the most, lighting on the map what each one would open, with what the tab cannot know and the command that does. A visitor with no file at hand can tick the servers they run instead. ~/.claude.json is recognised as Claude Code's, servers under a project included, and the sample's proposals, history and ledger leave when a config of the visitor's arrives. The tour's first card names what the next step opens in place of counting it.
#Claude Code is no longer told to set up the model it runs on
A Claude Code config names no provider unless a model is pinned, and most pin none, so the first step ambit offered a Claude Code user was Hosted Inference, which their agent was already using. A runtime whose model comes with it now declares that model: Claude Code and Claude Desktop the Anthropic provider, Codex OpenAI's, Gemini CLI Google's, and Cursor and Windsurf their own. Cline, Roo Code, Continue, Zed and VS Code take a provider the person picks, possibly a local one, so their configs are still read as written. The table is RUNTIME_MODEL in src/shared/runtimes.ts, which the engine's readers and the page share. A list of three or more next steps now reads "A, B and C" where it read "A and B and C".
#The counts in ambit status add up
The head of ambit status counts every reached node, the servers, tools and models in your config as well as the curated capabilities they provide, and the evidence rows under it counted only what carries a check, so the README's example read 39 reached over proven, unproven and failing rows that summed to 15. A fourth row, entries, counts the rest, and says they come from your config and that checks run on what they provide, so the column now adds up to the head. The unproven row says how many of its nodes are provable now, recovering, or have no check, so the last line's "11 of the unproven" has its 11 in the row, and the list of what ambit verify would check counts the names past its eighth instead of stopping there without saying so. The head, the rows and the domain totals take their nodes from one fragment in vocabulary.ts. Bare ambit said ambit verify runs the checks of every unproven capability, and now says how many of them have one. In --json, the evidence block gains entries, recovering and no_check, and provable_now lists every name.
#A docs page says what Ambit is before its answer, and opens the demo on it
Most visitors from a search land on a docs page that answers a question about MCP servers, not about Ambit, and those pages named what Ambit does in their last paragraph, under a brew install. The pages on config locations, outages and audits now open their answer with two lines on what Ambit does about that question and a link into the demo, and every page but the contributor guide ends on a card with the map, the demo and npx ambit-cli. A demo link can name the tour step it is about (?tour=outage, failing, yours), so the page on outages opens the outage and the page on config files opens the paste box; the tour also keeps its place by step name, because the sample's ranking arriving after it opened moved every step along by one. The header drops Jev, a page about one integration, for a Live demo button. The audit page now counts Cursor's hook among what fills the ledger, the no-JavaScript home text says what an approval covers, and the outage page no longer describes a headline the map stopped drawing.
#The latest check decides
A capability whose check failed came back only after five passes in a row, each typed by hand, so fixing a revoked token still kept three servers out of every plan until someone ran ambit verify five times. Now one passing check brings it back into every plan, permission and ranking. Until its last five runs pass it reads as recovering ("2 of the last 5 passed"): usable, counted with the unproven, and named in ambit status, the briefing, ambit verify, the map's panel and My Setup. A check whose last run failed is the only kind left out. ambit verify --failing re-runs recovering checks too, the Claude Code gate asks only when the last check failed, and a grant still widens only after a window with no failure in it. The degraded fields in JSON output keep their names and now list only capabilities whose last check failed.
#A service that stops answering stops counting
ambit incidents probed the services the infrastructure manifest names and opened an incident run for each one down, and that was all: a dead service stayed in every plan. Each probe of a device or service is now a check run on its node, the same row ambit verify writes, so one that stops answering reads broken and leaves every plan and permission, and the next answer brings it back. A grant resting on it asks a person meanwhile. Each answer also records when the device or service was last seen, and manifest entries can carry tags; both show on the Infra tab and in the incidents report, and neither travels in ambit sync. The probes still run only when typed, and the server's scan still writes nothing.
#Cursor feeds the work ledger
ambit connect cursor --ledger adds Ambit's hook to ~/.cursor/hooks.json, beside any hooks already there and keeping a .bak. Each conversation becomes a run, each shell command and MCP call a use timed by Cursor's own duration, which leaves out the wait for approval, and each failure a signal the engine classifies. The hook records names, lengths, ids, error text and why a conversation ended, never commands, outputs, arguments, files or prompts. It is on no permission hook, so it cannot block or allow a call, and AMBIT_NO_LEDGER=1 turns it off. Cursor's hooks report no tokens, so Cursor sessions record no spend.
#The OpenCode tracker no longer picks a graph
The tracker opened a graph itself, resolving it from where it was loaded. Copied into ~/.config/opencode/plugins/ as its install says, "the graph beside the engine" was ~/.config/opencode/toolchain-viz.db, the old default, on any machine that still had one, and a checkout's graph was never found, so configuration changes landed where nothing read them. It now appends each change to a spool, and the next ambit command or the MCP server reads it into whichever graph it opens, as with Claude Code. Copy plugins/ambit-tracker.js into ~/.config/opencode/plugins/ again to get this.
#doctor and status price nothing they did not measure
ambit doctor reported a token-thrash risk in dollars, and ambit status --json a context_thrash block: 32,000 tokens per failing check and 12,000 "prevented" per proven one, at $3 a million, with nothing measured behind any of it. Both are gone.
#Budgets have a meter
A budget's ceiling refused a caller that stated its spend, and nothing stated one: recordSpend had no caller, so spent stayed at zero and the pace bar on Time & cost had nothing to draw. Declare a model's price with ambit economics price <model> --input=5 --cache-read=0.5 --output=25, in dollars per million tokens, and from then on each Claude Code session's tokens on that model are priced when the session ends and recorded as a spend against the unscoped Hosted Inference budget, if one is set. A model with no price declared records no spend and is reported as undeclared, never as $0. Each session's tokens are counted once, a resumed session adds only what is new, and a price declared later does not reach back. OpenCode sessions, and anything else that does not state its spend, still record none, and spend lands when a session ends, so a spent ceiling refuses the next caller and stops nothing already running.
ambit sync kept one of a session's token rows and dropped the rest, since they share a run, a second and a kind. The key now adds the resource and its unit.
#A use has a length
Neither plugin timed a tool call, so the run view drew uses without lengths and Time & cost could not say where an agent's time went. The Claude Code hooks now spool PreToolUse beside PostToolUse with Claude Code's id for the call, and the engine pairs them. The OpenCode plugin times each call between its before and after hooks and records it as a use of what the tool exercises, which it did not record at all before. A call someone was asked to approve is left untimed, since its span holds the person's wait, and so is one whose start was not seen. To get this, update the Claude Code plugin with the next release, and copy plugins/ambit-telemetry.js into ~/.config/opencode/plugins/ again.
A Claude Code call stopped with Esc was recorded as a tool failure, because the hook dropped the is_interrupt flag Claude Code sends. It is recorded as stopped now, and no longer ranks the tool among what keeps blocking work.
#Re-run what is failing
ambit verify --failing re-runs the checks of everything degraded or broken now, and nothing else, so the command after fixing a shared token or a server is the same whatever broke. ambit status names it when more than one check is failing, and with --exit-code nothing left failing is a 0. A capability that failed needs its last five runs to pass before it counts again, so after a fix the command may need typing more than once.
#The timeline plays
Play on the map's timeline, or Space on the scrub bar, steps through each observation of the frontier in turn up to now, at a pace the sentence under it can be read at. Dragging, stepping, selecting or simulating pauses it, and the address follows the playhead without adding to the browser's history.
#The whole map, saved
Image on the map is a menu now: the card to post, as before, or the whole map, every era, node and edge whatever is on screen, as a self-contained SVG or a PNG at twice its size. The file is drawn from the graph, not the screen, so zoom, focus and scroll do not crop it, and it uses the standard lens, since the Attention and Authority lenses show who stepped in and what may act without asking. Fonts and colours are written into the file, and it carries no URL, path, command or person's name.
#The hosted demo leads with what one more step opens
The tour opens on the next step and what it would reach, and then the map it handed over to led with a red banner about the sample's failing check: the guardrail, sold as the product. On the demo the headline now names the best next step and the failing check is the smaller line under it. On a machine of your own a failing check still leads, since there it is news. My Setup orders the sample the same way, says it is a sample, and the readout of the seven steps is in plain words: "Your loadout, leg by leg" and "From A to B" were the docs' framing used as labels.
A visitor who skipped the tour had no way from the sample to their own setup, and no sentence saying what the page was. The header now carries a Sample tag, which plays the tour again, and Map yours, which opens the paste box and the install with one line on what an ambit is. On the tour's last card, pasting a config is the main action, and "Keep exploring" is the quieter choice.
The count in the header was five numbers. It wrapped at 1440px, read "12 next step", and gave the largest figure to what is blocked. It says verified, anything failing and the next steps; the tooltip has the rest. My Setup's readout calls the same 13 verified, which it had called proven.
On the map, reached nodes are filled so they read as ground held, where they looked switched off beside the next steps' rings. The four states sit in a strip under the map, the keystone is a small wedge instead of a dashed box that looked like a selection, and the map fits its width again when the window is resized, unless you have zoomed. In the outage, what stopped is filled red and what was never set up is a red outline, so "4 things stop" is four red circles and not sixteen. During the tour the lit part is framed clear of the card, and the card slides when the detail panel opens. The panel calls a node whose check is failing Failing, and no longer says "If this went down, nothing else would stop working" about something already down. On a phone the lens switch fits on screen.
#A page on another local port is not Ambit's page
The origin check compared the hostname and ignored the port. Every page on a machine is on localhost, so another project's dev server, or python -m http.server in a downloaded folder, passed as Ambit's own page and, with no token, could read the agent config, switch an existing MCP server on, and approve or turn down drafts. An Origin now has to name a loopback host on a port this app serves its page from: the API's own, and in a checkout the Vite port that npm run dev gives both processes as AMBIT_WEB_PORT. Vite takes that port or stops, so it never moves to one the API would refuse.
/api/telemetry took a post from anything that could reach it, which was harmless while it only recorded work. A use inside a run that ended in success counts toward a promotion threshold, though, so a post could bring forward the widening of a grant a person had set a threshold on. The route now follows the token rule the config and decision routes follow. The server writes the token when it starts, and the OpenCode bridge and the stdin adapter present it. A copy of plugins/ambit-telemetry.js made before this release posts without it and is refused, so copy it into ~/.config/opencode/plugins/ again.
#The docs say one thing about what counts
The glossary said a capability counts only once it is proven, the README said it counts once its check passes, and the engine counts what is reached and lets a failing check take it away. Three versions of the installed, working, authorized chain ran across four pages, one of them six links long and grading itself, and the map was "every tool and credential as a point" on one page and "the curated tree with your position on it" on another. Each is now stated once: reached counts, proven is the part a passing check backs, permission is a separate layer, and the gate binds in three places, ambit apply, the control plane for what is routed through it, and the Claude Code hook.
The pages were rearranged around that. The README says what Ambit is before the journey from A to B, and the Eva picture moved to the end of the loadout page as an aside. The deep dive gained a section on how a setup reaches further, defining the frontier, next steps, near misses, keystones and combos, with fragility after it as what that reach rests on, and lost the maintainer histories and the counts that drift. The roadmap's status table lists only what remains, the interface specs open on what they are now, and the how-to pages give a method by hand before the commands, advice that follows from the diagnosis, the project-scoped config files Ambit does not read yet, and what each step needs before its output means anything.
#Budget amounts the shell leaves alone, and a version to report
Every example of ambit budget set wrote --amount=$20. Typed as shown, bash reads $2 and a 0, so the command set a $0 ceiling and refused every stated spend after it; zsh reads $20, which is unset, and the command failed. The examples now write --amount=20, an empty amount says to leave the $ off, and a zero ceiling is set with a warning naming the likely cause.
ambit --version reached the engine as an unknown command and began a first-run seed. It now prints the version from package.json before the engine starts, and the bug template asks for it.
#Tokens on Time & cost
The token counts the Claude Code hooks read from each session's transcript now have a figure on Time & cost: the month's total, and per model a bar of fresh input, cache reads and output, written as 2.5M and 41.3M, not nine digits. Cache reads are drawn in the quietest colour, since they are most of a long session's count and the cheapest part of it. The figure says where the counts came from and that no price was applied, and it is not drawn at all when nothing was recorded. A ledger holding only token counts no longer opens on "Nothing recorded yet". The hosted demo carries a month of sample sessions.
#Figures written the same way in every region
A dollar figure took its "$" from the code and its digit grouping from the browser, so in Berlin or Paris the headline on Time & cost read "$9.600", which is nine dollars sixty to anyone else, and a ceiling read "$12,40". Every dollar figure now goes through one formatter with US separators, whole when whole and with cents when not, so a saving of 43.2 reads $43.20. Dates and clock times follow the first English the browser asks for: a British reader gets "6 Oct, 14:05", an American one "Oct 6, 2:05 PM", and a browser that asks for no English gets the American form, so "6. Okt." no longer turns up inside an English sentence. The Audit trail and a run's clock drop the leading zero nobody writes on a twelve-hour clock ("8:23 AM", not "08:23 AM").
Time & cost had three date formats on one screen, and its "Since 2026-09-08" now reads like the other two; a day outside this year carries its year. A payback under a month is said in days ("Pays back in 9 days") instead of "0.3 months", and the ends of the hours figure read "Jan · 11h", which had read as the eleventh of January. The copy settles on American spelling where it had both, "judgment" and "judgement" among them.
#Three faces, one job each
IBM Plex Sans set everything, titles, figures and labels alike, so a count read at a glance had the same voice as the sentence beside it. The map, the panel and the saved image now set three faces. Hubot Sans is the readout: wide for titles and figures, narrow capitals for era headers, section labels and the spec-sheet callout, the way an instrument panel sets them, and its barred zero is the readout convention. Mona Sans, drawn beside it, is the text, and Monaspace Neon, from the same family, is what a person types. The saved image used to fall back to a system face, since an SVG drawn as an image cannot reach the page's fonts; it now embeds the two it sets. The docs pages take the same pair. All three are served from this origin, latin only, which also stops Vite bundling every subset fontsource declares.
The rest followed from giving each role one face. A card's or a proposal's heading sets the readout face at its own width, between a title and the text. Every caps label, which had been set by hand five slightly different ways, takes the one narrow setting, and My Setup's groups join them. Tabular figures came off sentences, captions and times: the text face draws its tabular digits as code, a slashed zero and a footed one, which read as a readout in a column of numbers and as a typo in "pays back in 0.3 months". The cards catch the light along their top edge, and the one icon on a card heading, which no other card had, is gone.
#Claude Code sessions reach the work ledger
The ledger was fed by the OpenCode plugin, the control plane and MCP calls, so for someone on Claude Code the Time & cost view stayed empty, no grant could earn a promotion, and ambit next never learned what blocked work. The Claude Code plugin's hooks now record which tool each session ran, which failed and with what error, and when a person was asked to approve one, and a session's token counts per model are read from its transcript when it ends, with cache reads apart from fresh input and no price applied, since none is stated. A hook runs before Claude Code takes its next step, so it does one thing: append a line to ~/.local/state/ambit/claude-code.jsonl, in about 50 ms, never a tool's input or output. The next ambit command, or the MCP server when it opens the graph, reads the file in and removes it; a tool call becomes a work event and a use of each capability it exercises, found the way the gate finds them, and a failure is classified by the engine. AMBIT_NO_LEDGER=1 turns it off, and the test suite points the spool elsewhere so running it never consumes a developer's own.
The gate plugin, installed without an installed ambit, steps aside on each call and says once per session that it is inactive and how to install it, instead of failing on every tool call or staying silent while a person believes a guardrail is on.
ambit connect registers the MCP server in the six runtimes it read and could not write: Gemini CLI, Codex CLI (a TOML table appended, the rest of the file kept), Cline, Roo Code, Zed and VS Code, each where its reader looks and in the shape its reader reads. Run from npx's cache, it writes npx -y ambit-cli mcp, since a copy npx unpacked has no ambit on the PATH.
Budgets still have no meter: a ceiling refuses a caller that states its spend, and nothing yet records spend in dollars, which Claude Code does not report.
#ambit impact says what ends and what survives
It printed through the generic formatter, so the answer read becomes unavailable: false and also provided by: 5, with every capability listed twice. It now leads with what stops working, marked ›, then what survives only on providers that all present one credential, what survives on others and on how many, and what loses an optional input. Two wrong answers went with it: a server's own credential was listed as something that decays when the server goes, and ambit impact credential:… answered with nothing at all, because a key's edges point at it. A credential's impact is now what revoking it ends, the same computation as ambit credentials. The README carries the example again, captured from the fixture. Closes #76.
#VS Code's own MCP servers
VS Code keeps the servers it runs in a user-level mcp.json, under servers, apart from the Cline and Roo Code extensions Ambit already read, so those servers never reached the graph. They do now, as a twelfth runtime, with VSCODE_MCP_CONFIG to point elsewhere: contributed by @webdevsamran in #83, closing #77. Every place that lists the runtimes, the social card included, says twelve.
#Issue Tracking
Issue trackers are among the most common MCP servers and no node covered them, so ambit goal "file an issue" routed nowhere and a Linear server sat on the map unmapped. Issue Tracking is in the Tool Use era beside Data Access, detected from Linear, Jira and the rest of the Atlassian suite, YouTrack, ClickUp and Asana; reading runs on its own, commenting, filing and closing ask, and deleting is refused. GitHub is left out of the patterns because they would match a Copilot provider too. Error Tracking no longer claims "bug reports", which is a tracker's phrase, so "triage incoming bug reports" stays the docs' example of a goal only --judge can route. Closes #79.
#0.6.0 — 2026-10-01
The first release on npm and in the MCP registry, and the first that helps someone running a product, not only an agent setup. In short:
npx ambit-cliruns it with nothing installed, and its first screen says what it read and what one more step would open.- Building alone. Two eras, Product and Operations, hold what running a product needs: hosting, a production database, backups, error tracking, uptime, payments, accounts, email.
ambit goal "launch my saas"is the checklist in order, and each node arrives with defaults that read freely, ask before a customer would notice, and refuse what cannot be undone.ambit people addlets someone with no OpenCode config set a budget and approve. - The route and the unlock. The map numbers the steps to a node in the order they close, and a seed that reaches something says what, and what came with it.
- The map from any install.
ambit webserves the built page on localhost from npm, and from Homebrew once the formula moves to the npm tarball. The page fetches nothing from another origin, fonts included. - Two fixes to authority. A question that names no target is inside no scope, so "autonomous on staging" no longer answers yes for an untargeted call, which every Claude Code tool call is. And a tree overlay, which a cloned repository can ship as
.ambit.json, may narrow a curated authority mode and never widen it.
#An overlay narrows authority, never widens it
A tree overlay is read from the working directory, so running ambit or the MCP server inside a cloned repository that ships .ambit.json applies it, and the overlay's authority block replaced the curated one whole: an overlay saying a refund was autonomous made ambit can act:payments/issue_refund answer yes where the curated tree refuses. Every curated mode is now kept, the narrower of curated and overlay wins per key (with override: true too), and a mode the curated tree never stated is capped at confirm.
#One wording per thing
A pass over every surface closed the places it said one thing two ways: every copy button now answers Copied ✓, the detail panel's history row is a section label like the five beside it, and the guide and proposals dialogs name what their close button closes. Eight passages in the docs that described their own page, where a heading or an outline already did, are gone.
#On npm: npx ambit-cli
ambit-cli is on npm, so npx ambit-cli reads every agent config on the machine and prints where you stand, with nothing installed first and Node 22.18 or newer the only requirement. npm install -g ambit-cli keeps it, beside Homebrew. The README, llms.txt, the welcome screen and the Claude Code skill lead with it, and the ambit Claude Code plugin now runs its MCP server and briefing through npx, so installing the plugin needs nothing else. The gate plugin keeps calling an installed ambit, since it runs on every tool call.
#Nothing fetched from another origin, and a formula that carries the map
The page took IBM Plex from Google Fonts, so opening the map, the local one included, asked Google for a stylesheet on every visit. The fonts ship with the page now: the latin subset of the weights in use, about 130 KB. A test fails if index.html gains a stylesheet, script or image from another origin. The Homebrew formula is written from the npm tarball from 0.6.0, the same files npx ambit-cli runs, built page included; it installed the GitHub source tarball, which has none, so ambit web from Homebrew had nothing to serve.
#The route on the map, the unlock said aloud, and the map from any install
A blocked node's panel lists the steps to it in the order they close, and "Show the steps on the map" numbers them there, each after everything it needs, the way Civ numbers the path to a distant tech. The gap had been a set lit all at once, which said what stood in the way and not where to start. With the panel open, the map now scrolls a simulation out from under it, so Launch Ready's steps in the last two eras are not numbered where nobody can see them.
Reaching something is said when it happens. ambit seed prints what it reached: "↑ Reached Hosting, and with it Error Tracking" when Sentry was waiting on a host. The short ambit screen says what moved since you last looked, once. The map's live reload names what was reached and what became a next step, instead of saying only that it reloaded.
ambit web works from an npm install: the package carries the built page (about 650 KB) and the compiled API server, which serves it on the first free loopback port from 3001 and opens it. The short ambit screen points at it. The package no longer carries the test harness. The release workflow's npm job installs the dev dependencies packing needs, and has the id-token permission --provenance needs.
#Building alone: a launch checklist and production defaults
The curated tree knew what agents could do and nothing about running what they build, so ambit goal "take payments" and ambit goal "back up my database" routed nowhere. Two eras now hold what a product needs, detected from the MCP servers people already use: Product (Hosting, Production Database, User Accounts, Payments, Transactional Email) and Operations (Error Tracking, Product Analytics, Uptime Monitoring, Backups, and Launch Ready). Launch Ready is a capstone, reached when hosting, a production database, backups, CI, error tracking and uptime are all in place, so ambit goal "launch my saas" is that checklist in order. A plan now prints as one: each step's time, what to do, the usual ways to do it, and a step already half done (Sentry configured before any host) said as such. Each new capability carries the defaults a careful CTO would set: read freely, ask before a customer would notice (a production deploy, a migration, a payment link), and refuse what cannot be undone (deleting the project, dropping a table, a refund, deleting a user, a broadcast email).
ambit people add <id> declares a person from the terminal, so someone with no OpenCode actors block can set a budget and approve a proposal. It grants nothing, the way the web server's own person grants nothing. Building alone is the page for this reader.
A question that names no target is inside no scope now: "autonomous on staging" answered yes for a call that named no target, which every Claude Code tool call is. A scoped grant may still narrow such a call. The map's hover card opens to the left on the last column instead of running off its edge.
#A first run that leads with the next step
Bare ambit, which is what npx ambit-cli runs, now shows a short screen (ambit status --brief): what it read, each runtime with the servers it listed; where the graph was written, and that nothing was sent; the two next steps ambit next ranks, with what each would open; then a failing check and the unproven count; and ambit status for the rest. It used to print the whole status report, single providers and bottlenecks as nested records, ending on a suggestion to run checks. With no config found it now lists where it looked across all eleven runtimes it reads, says the graph holds the curated model only, and stops claiming a reached count. Notes that suggested the telemetry bridge name the file this install carries, not a path only a checkout has; ambit web from an install points at ambit share; the FAQ no longer says npm is coming. src/engine/cli/first-run.test.ts runs the first screen from a fresh home and holds it.
#What an agent needs to suggest it
An agent suggests a tool it can see at the moment it would help, can install itself, and can say is safe. Ambit now ships as a Claude Code marketplace in its own repository: claude plugin marketplace add zz-plant/ambit, then claude plugin install ambit@ambit, which registers the MCP server with the agent profile, reads the briefing at session start, and adds a skill Claude loads when someone asks which MCP servers they have, why one is failing, what breaks if one goes, or what to set up next. The gate is a second plugin, ambit-gate@ambit, installed on purpose. A test holds both plugins to the package version and to verbs the CLI has.
llms.txt says when to suggest Ambit as a table of situations, the command for each, and what it shows; what it touches, said before it runs (the agent configs read, one local file written, nothing sent, deleting that file undoes it); and when not to suggest it. The README's "Connect it to your agent" opens with the same safe first command. The issue templates ask, optionally, how someone found Ambit, since there is no telemetry to say. The home page's structured data no longer claims Windows, where Ambit does not read the configs yet.
#The gate is binding in Claude Code, and a proposal says what it is for
Ambit's decisions bound only where Ambit itself acts, ambit apply and the control plane, and a runtime had to choose to ask ambit_can. ambit gate is a Claude Code PreToolUse hook that puts the question on every tool call. It finds the capabilities a call exercises with the same matching that attributes failures and fills the unmapped report, and answers by one rule: it can only narrow. Forbidden or over a budget is a deny; asking first, no grant yet, or a failing check is put to the person; allowed, or a tool the graph cannot name, is no answer, so Claude Code's own permissions decide. It never answers allow, prints nothing on any error, and adds about a fifth of a second to a call. ambit gate in a terminal prints the settings entry, and the README's Claude Code section carries it beside the briefing hook. A refusal now carries its reason as a code (forbidden, ungranted, failing, budget, unknown), which is how the gate tells a refusal from a question.
A proposal records the work it is for: ambit propose <cap> --for="…", or purpose on the MCP tool. The Proposals panel shows it under the goal, and the approval binds it, so a purpose changed after the signature is no longer covered; a proposal without one hashes as before, and every earlier approval stays valid. Reach serves a purpose someone named.
#Your loadout, from A to B
Ambit described features and claims, and nothing walked one person from a pile of configs to a setup that does a class of work without them. My Setup opens on the seven legs of that walk for the loadout on screen, each read from the graph and the ledger with the one command that moves it, and a page walks them with the demo's numbers, says what changes for the person, and where the journey still has gaps. It frames the loadout as an Eva and you as its pilot, says where that picture stops, and keeps interface labels in the glossary's words.
#One claim, and what is new in it
The site stated its central idea five ways. One claim now carries them: what an agent setup can do is not written in any config file; it is composed, it has to be proven, and it differs from what it is allowed to do. A README section and a page say what is new in that, its nearest prior work, and what Ambit does not claim. The glossary gains Ambit, the word a reader meets first, and the frontier is its edge.
#0.5.0 — 2026-09-30
A month of rounds since 0.4.1, none of which Homebrew had until now. In short:
- OpenCode 2 is read and written in its own shape, and both plugins run under it as well as under OpenCode 1.
- An MCP server an agent can predict. A call is checked against the schema its tool advertised, a tool marked read-only is held to it by a test, one resolver decides which node an id means, the server sends its own
instructionson connect, and--profile=agentlists ten tools in 4.4KB. - A CLI a script can read. Output is plain off a terminal, a command that reports an error exits 1, and
--exit-codeoncanandverifymaps the answer to a code. - A map that holds a large setup. Focus, a minimap, a timeline that replays the map as it was, the Audit view, a queue that decides several drafts at once, the last fourteen check runs on each My Setup row, and one run laid out in time.
- Authority for a window (
--ttl=30m), a curated tree you can extend from.ambit/techtree.json, andambit dispatch, which pushes a draft to Slack, Discord, Telegram or ntfy while the decision stays on the machine. - Jev on the map, routing goals and kept off the authority path.
- A map that points at what is broken and gives itself the screen: the failing check alone in the headline, corner brackets and stripes, a Key and a History button where a legend and a timeline took bands of their own.
- Who acted, and each ask with its answer: actor marks, a run's asks as exchanges, approvals as receipts with a seal, and who drafted each proposal.
- Pages for what people search for: where each agent keeps its MCP config, what breaks if a server goes down, auditing an agent's servers, and a glossary.
#The front page says what an ambit is, and how to widen yours
The README had reached 6,400 words, and nothing on it said what an ambit is before using the word as the product's name. The line under the tagline now does: what you, your agents and your machines can jointly do is your ambit, and the tool maps it and shows how to widen it. The four questions lead with what is one step away and what to set up next, and verification and blast radius follow as what makes the widening safe to lean on. A section says who it is for, and a small setup is named as the one with the most ground ahead.
What it moved, it did not cut: the map's marks, focus, minimap, timeline and proposal queue went to the deep dive's map section, the delegation loop to its delegation records, and the exit codes to its CLI surface. Jev left the comparison table for docs/jev.md and the FAQ, which already carried it.
Four statements on the page were short of the truth. It named seven runtimes and Ambit reads eleven. The browser accepts any MCP config, not only opencode.json. Homebrew brings the CLI and the MCP server and no map. And the snippets now lead with --profile=agent. The goal and impact console blocks are gone until each has a renderer of its own, because they printed the generic key/value formatter and read as debug output.
#Pages that answer what people search for
The hosted docs gain four pages for questions the web answers badly: where each of eleven agent runtimes keeps its MCP config, taken from the readers that parse them; what breaks if an MCP server goes down; how to audit which servers a coding agent has; and how Ambit differs from an MCP gateway on the call path, and how the two compose. A glossary page is written from concepts.json, the file the app and ambit help read, so it cannot define a term differently.
The FAQ is marked up as questions and answers, parsed from its own headings; the glossary as a defined-term set; and every docs page carries breadcrumbs and the date its source last changed. Titles that named only the product say what the page answers, and the home page's heading and description use the words a search does. ambit share snapshots link to the site, Time & cost and Audit load when first opened (the first script is 41 KB smaller), and ambit impact with no id prints its usage, where it crashed on a missing query parameter.
#Who drafted a proposal, and an approval listed once
A proposal records who drafted it. Over MCP it is the runtime that called, by the name its handshake gave, reduced to a slug (agent:opencode); on the CLI it is whatever ambit propose --by= names, and nothing without it, since a terminal can be a person or an agent's shell; the control plane's drafts are ambit. The column arrives through ADDED_COLUMNS and is left out of the proposal's hash, so every approval already minted stays valid. The Proposals panel draws the request beside the drafter's mark, and Audit names the drafter on the proposed line.
The trail could list one approval twice. The proposal row and the approval's act are written by two statements, each reading the clock, and the trail matched them to the second; when a second turned between the two writes, both stayed. The newest act for the proposal is what tells them apart, and the time now only has to fall within two seconds. A loaded test runner found it, and a test now pins the skew directly. A month test that read only the newest month failed on the first two days of every month, and reads the whole series.
Esc closes the map's key before it clears the highlight the key set, and a press outside the key closes it. Between 769 and about 1180 pixels the headline covered the map's tools and the header's pill wrapped; the headline takes the row under the controls there, the canvas reserves room from where it ends, and the pill keeps the counts a person acts on. Dependencies move to vite 8.3, vitest 5, biome 2.5.15 and React 19.3.
#Who acted, and each ask with its answer
Actors are drawn: a circle for a person, a rounded square for an agent, a hexagon for a machine and a diamond for Ambit, each with a monogram, and only for an id whose prefix says which. A guessed avatar would be an identity nobody declared.
A run's asks are exchanges: the recorded request on the left, the answer and its wait on the right, and an empty dashed reply where nothing recorded one. The request is the capability and action the ledger holds, never a sentence written in the agent's voice, because the ledger does not store the prompt's words. A proposal is drawn as a request and an approval as a receipt under it, with a seal and the signer's mark; the seal marks a signature and nothing else, so Audit's signed lines carry it where a passing check keeps its tick. The briefing reads as what it is, Ambit's message to the agent at connect, and an outage simulation labels the node that went down with how many capabilities stop.
#The map gets the screen
The map sat inside seven bands of chrome: on a phone it had about 45% of the screen, and at 1440x900 the legend was below the fold. The legend is a Key opened beside zoom, as buttons that light their nodes, and a lens opens it by itself. The timeline waits behind History. A failing check is the headline alone, with the week and the worst loss following the next step only when nothing fails. Image moved from the header to the map it saves, the minimap stays out of an open panel's way, and the source plate is drawn on phones only. On a phone the map has about 65% of the screen.
Edges that cross more than two eras are faint until a node they touch is in focus. Stripes mean one thing, a state that refuses: a failing check, a forbidden grant, or a spend past its ceiling. The type is eight sizes and four weights, where it was seventeen and eight. Time & cost leads with what a first read is for, from 3,528 pixels to 2,746: what could break is one line, the hours card no longer repeats the headline, and an opportunity's ways to get it, the explainer and a run's lanes open on demand. One filled button a view, a red outage button only when the outage stops something, commands that wrap where they were cut off, and names haloed so an edge stops at them.
#The map points at what is broken
The headline leads with the failing check, where a hypothetical about the worst loss led. The selected node and the node the headline names carry corner brackets, a shape nothing else on the map draws, and a failing node and a forbidden grant are striped, which survives a greyscale screenshot where a red does not. The share image stripes a node that was already failing and labels it with a callout, so it needs no legend. On a phone the map frames what is lit at a readable zoom, and the Image button saves a 1080x1350 card of what the map shows.
#OpenCode 2, and a Jev clone found where its SDK looks
OpenCode 2 renamed most of its config and moved MCP servers under mcp.servers, and Ambit read a V2 file as V1. The map drew one server named "servers" and nothing else: every agent, command and provider sat under a key the seed skipped, and a model pinned as provider/model#high never met its model. src/shared/opencode.ts reads either version into the one shape every reader already used, as OpenCode itself does in memory, and the seed, the API's read-out, repo drift, the infrastructure scan and a config dropped on the page all go through it. opencode.jsonc is read too, comments and all, when it is the only config there.
An edit goes back in the shape the file has. The My Setup switch writes disabled into a V2 file and enabled into a V1 one, ambit connect opencode adds mcp.servers.ambit to a V2 file, the snippet the page offers is in the file's shape, and ambit apply, rollback and a removal find a server where V2 keeps it. A commented file is never written back, because writing it would delete the comments: the switch answers 409 and ambit connect says to add the entry by hand. ambit connect used to replace a file it could not parse with {} and one entry, deleting everything a person had in it, and now leaves it as it was.
The rule OpenCode states for running a shell command, permission.bash in V1 or a shell rule over * in V2's permissions, reaches the graph as the runtime's authority, as Claude Code's defaultMode already did. A rule for one command such as git push * says nothing about the rest and is not read as the general rule, and an authority block of Ambit's own still wins.
OpenCode 2 does not run a V1 plugin, so both plugins stopped recording anything under it. Each now default-exports { id, setup, server }, the pattern OpenCode's guide gives: V2 runs setup and V1 calls server. Under V2 a run is a session, a tool that exited non-zero is a failure even when the call completed, and a permission prompt is recorded when it is answered, with what the person decided and how long the agent waited, which V1 never reported. The tracker records what a config.updated event added or removed, by comparing what OpenCode lists before and after.
ambit goal --judge asks a local clone that TYPESAFE_BASE_URL (or JEV_BASE_URL) already points at, which the curated tree tells a person to set and the judge did not read. Only a loopback value is taken; the hosted API in the same variable is passed over, not refused. An answer carrying only Jev's choice and confidence is read at that confidence.
#An MCP server an agent can predict, and a CLI a script can read
Each of these was measured first, with a probe that called every tool with missing, misspelt and near-miss arguments, another that hashed every table around every call, and the CLI run through a pipe.
Connecting now tells the client what Ambit is. initialize carries instructions, the one habit the README asked you to paste into your agent's rules (ask ambit_can before a tool you have not used), and answers the protocol version the client asked for when the server speaks it, 2024-11-05 or 2025-06-18, where it had answered 2024-11-05 to everyone while sending a field only the newer one defines. ping is answered. A notification is never replied to, and a line that is not JSON is answered with -32700, where each of these left a client waiting or reading an error it could not match to a request.
Every tool carries annotations. Forty-six say they are read-only, and a test holds that against the database: each is called against a copy of a seeded graph and no table may differ. ambit_can, ambit_briefing and ambit_context are listed as writes although agents call them most, because can files a deficit and the other two move the mark for what changed since you were last told. The catalogue shows one name per capability argument and marks required where a capability is needed, and capabilityId and capability are still accepted.
A call is checked against the tool's schema before it reaches the engine. Most tools that need an argument answered its absence with an SQLite bind error, a CLI usage line that told the agent to run a shell command, or a TypeError from inside a string method, and ambit_verify called with a misspelt name ran every declared check, because no capId is how one asks for all of them. The check names everything wrong at once and says what the tool takes. It is lenient where the meaning is not in doubt (null, "14" for 14, capability_id for capId) and refuses the rest. A failed call is isError: true, by one rule the CLI shares, a top-level string error, and an unknown tool is -32602 that names the one probably meant, where it was -32601.
One resolver, resolveCapability, decides which node an id means. A slightly wrong id was answered six ways: ambit_impact offered near matches, ambit_verify said "No capability nope in the model", ambit_evidence answered an empty list, ambit_actions said the capability declared no contract, and ambit_simulate reported a larger frontier for acquiring a node that does not exist, as ambit goal <id> --simulate did. It normalises a prefix, a case and a display name, and never chooses between two nodes or invents one. ambit can treats a near miss as a slip on both surfaces: it answers with the candidates and files nothing, where shell-exection was filed as a deficit and read as "you may not run a shell", and ambit can with no capability threw.
Answers are smaller. The text half of a result is compact JSON, about a quarter fewer bytes on a typical answer, since a client may send both halves to a model. ambit_authority returns who may act alone, who must ask and what is forbidden, 0.7KB where it was 16KB, and the row for every grant only with detail: true. ambit mcp --profile=agent (or AMBIT_MCP_PROFILE=agent) lists ten tools in 4.4KB where the full listing is 19.5KB, and every tool still answers by name. The full listing held its 20,000 byte limit while gaining the annotations, by shortening descriptions.
The briefing counted a failing action in the figure beside a count of capabilities, and read 4 where ambit_stats said 3 for the same machine. It counts capabilities as status does and counts a failing action after them.
On the command line, output is plain unless stdout is a terminal, and seed, help <term>, the first-run line, an unknown command and the wrapper's own help lines no longer paint a pipe. A command that reports an error exits 1, and an unknown command prints to stderr and exits 2, where both exited 0 and ambit sync && next ran next after a usage error. ambit can <cap> --exit-code exits 0, 1 or 2 for ALLOW, CONFIRM or DENY, and ambit verify --exit-code exits 1 unless every check that ran passed, as git diff --exit-code does for a diff. ambit plan, govern and report on their own list their verbs, which ambit help had told the reader to try, and ambit init-rules writes the ask-before-acting habit into the rules file.
#A page whose keys, focus and counts each have one owner
A second look at the page, in a browser and from the keyboard, found several things the last release built disagreeing with each other. Starting an outage on a scrubbed map played it on the scrubbed day, so an outage read a machine the header did not describe. An era's ladder read today's nodes under a header that counted an earlier observation, so "Model Access" said 1 of 6 reached over a ladder that said 3 of 6. The header's pill filed a reached node whose check is failing under unproven, and read 13 verified and 3 unproven, 16 reached, over era headers that add up to 15 reached and 1 failing. The ladder says which observation it reads, a simulation returns the map to now, and failing is a segment of its own.
Keys had no single owner. The shell and the map each listened for Escape, so a selection, a simulation and a spotlight cleared in the reverse of the map's order, and the docs and the selection behind them closed in one press. The finder stopped only Escape, so an arrow key stepped the selection on the map behind it and g opened Proposals over it, as it did on the run chooser's select. Ctrl and = zoomed the map with the browser's own zoom stopped. One escapeLayer decides what a press closes, the finder stops every key, a select keeps its own, and a key held with Ctrl, Cmd or Alt is left to the browser. Proposals and the docs opened with the focus on the page behind them, so Tab walked some seventy stops of the map first. A dialog takes the focus now, keeps Tab inside and gives it back, and the docs dialog has a name.
The rest is where the page was not sized for what it holds. The minimap unmounted in the middle of a drag at the bottom of the scroll, because "does the map fit" was asked of the viewport where it stood. At 900, 800 and 769px the headline wrapped onto the era names, which are controls, and at 1100px and below the first-run card sat over its own button. The headline's height is measured and reserved. The deck ran out of room: Docs clipped at 1241 to 1280px, Proposals and Docs past the edge at 1024, and Audit, Share and Time & cost gone at 900. The view tabs are icons with a label up to 1180px and the buttons up to 1380px, so every control is on screen from 769px. A link with collapse=1 and no node collapsed the map the moment anyone clicked one, 35 nodes to 8 on the demo. Leaving the map left an era's ladder open over My Setup.
A run with only a start read "Run of 1s" over a one-second axis, and one with no time began at midnight, so no length is stated and no axis drawn without a real stretch. Safari throws once a page writes history a hundred times in thirty seconds, and scrubbing writes once per tick, so a refused write is skipped. An engine that predates /api/run left a section on "Reading the ledger..." for good. The view tabs mark the current one, the timeline's slider and its Frontier term are 24px at 390px, and the slider's focus ring is the page's, where it had been 2.4:1.
Each was seen in a browser before and after and has a test that fails without it. The README's hero GIF and two stills are re-recorded, because the pill and the buttons in them changed.
#A map that fits a large setup, and that remembers
A map of a few hundred nodes had nothing to hold on to: selecting a node dimmed the rest and hid none of it, nothing said where on the map you were, and the frontier's history was a table in the terminal. Focus, from the panel of a selected node, now keeps only what it needs and enables within a chosen number of hops in a chosen direction, and a pill says how many nodes it hides and ends it. It is opt in, because every existing link and the tour select nodes, and the URL carries collapse, with depth and dir when they differ from their defaults. A minimap appears when the map is bigger than the window, with a red dot for every failing node and the part on screen outlined, and the line over the map says which way a failing node lies when it is out of sight. An era header opens a ladder of what is reached, what is a next step with its setup time, and what is blocked by what, with a node whose check is failing counted apart from reached.
A timeline under the map has one tick per second in which the ledger took a snapshot, and dragging its playhead redraws the map as that observation left it, with today's names and edges. ambit history since <when> [<until>] and the MCP tool compare any two observations through the same function, so the page and the terminal say the same sentence. Building it found that frontierAt compared ISO timestamps as strings, which put a whole day on the wrong side; it parses them now and breaks ties on id. The MCP tool listing is 19,482 of its 20,000 bytes, so the next tool added has to shorten another description.
#Setup that shows how each check went, and a queue that decides each draft on its own
A My Setup row said "check passed" or "check failing" and nothing about how long that had been true. Each row now draws the last fourteen runs of the checks behind it, a failure taller than a pass, and a failing row copies the ambit verify command for the node that is failing. A tool server's row has a switch that writes enabled to the config it came from. The visualizer's config editing now keeps the file it replaces as <config>.bak before every write and refuses the write when it cannot, which SECURITY.md had said it did and the code had not.
A proposal reads as a plan before anyone approves it: a tally above the steps, a mark on a step with no inverse, whether ambit apply would refuse it, and a before and after forecast. When two or more drafts wait, a sheet lists them with a box each. POST /api/proposals/approve and /reject take at most fifty ids, decide each in its own transaction as human:web, bind each to the hash the page showed and refuse one whose row changed, so a stale draft fails alone and the rest still sign. Both are behind the API token when no browser is making the request. The Audit tab lists who approved what and what ran, one line per event, newest first, from four sources under one limit, with actor:, action: and target: in the query bar.
#Time & cost that shows the ceiling, what a way in needs, and one run in time
A standing budget was a bar with a number. It now draws its ceiling and a tick where the period lands at the pace so far, and says a spend past the ceiling is refused until the period turns over. That is what the gate does for a caller that states its spend; the roadmap and the notes in budgets.ts had said it goes back to asking, which no code path does, and a budget bounds a grant without widening one. Each opportunity says what its capability needs and whether that is here: a required prerequisite is met, missing or failing its check, and a declared credential is named and never marked, because nothing checks one. Each way to acquire it carries its install text, read from the shipped tree only. One run draws in time with a lane for the person who was asked, an ask with no recorded end drawn as a point and never as zero. The Infra tab shows what an agent may do on each device the scan found, from the same gate ambit apply uses.
The finder lists actions beside nodes (an outage, an unlock, a lens, Proposals, copying ambit verify) and Enter runs the one chosen. It only ever copies the verify command, because a check is a command an agent may have registered. ambit status ends on the one thing to type next, coloured on a terminal and plain in a pipe, and the README's example block ends on it too. The README's hero GIF and two stills are re-recorded from this build.
#A palette of its own, a map whose edges meet its nodes, and a header that fits a phone
The interface wore a CSS framework's defaults: slate grounds, an indigo accent, two radial glows behind every view and frosted glass on every panel, set in Inter at eleven and twelve pixels. It reads as generated because it was. The ground is now a near-neutral ink, the accent a soft blue that carries dark text as a fill, the status colours a step softer, and the type is IBM Plex a size larger throughout. The glows and the blur are gone. The mark had kept the old colours, a white A on a gradient of indigo into sky, on the header, the favicon, the iOS icon and every link card; all four now show one flat plate of the accent with the A cut in the ground colour, and the header's copy, which had drifted to thinner strokes than the tab beside it, uses the generator's numbers.
Every edge on the map was drawn 24 units left of the nodes it joined: layoutNodes placed edges at one x and the renderer drew circles at another, so each line entered its circle off centre. Both now read one columnCentre. Reached nodes are a quiet filled disc in place of a sea of violet with a white dot in each, a next step is the bright ring, a blocked node keeps a legible name instead of fading to three quarters, and edges are grey until a node is in focus. On a phone the map opened at 40%, where a name is four pixels tall; it opens at a readable scale and scrolls, and a simulation scrolls to where it starts.
At 390px the header scrolled sideways and Proposals and Docs sat past the edge with nothing to say they were there. A phone gets two rows: the brand and the actions, then the three views across the full width. The proposal cards were flex items with overflow: hidden, so each was squeezed to fit the list and cut its steps off mid-line; the Docs tabs were squeezed the same way until their labels were cut in half. The header's verified count held a glossary button inside its own button, which React reported on every load.
The copy lost what gave it away: an uppercase eyebrow over the Time & cost headline, an icon before every card title, callout boxes with coloured left edges, Title Case in the demo's proposals, "Record the no", hotkey docs that listed two lenses of three, a Docs page that called the columns "areas of work" when they are eras, and descriptions joined to their hints with a second dash.
#Every view says what it found before it shows the evidence
The interface computed what mattered and then printed it in its quietest type. On the map every reached node was the same saturated disc, the next steps that are its recommendations were thin outlines with a nine-pixel cost, and blocked nodes were faded until they could barely be read. Reached is now the quietest filled state, a next step carries the heaviest ring with its cost in the accent colour, a blocked node is a dashed gap that stays legible, and a failing node is ringed in red. One line over the map states the finding: a capability configured and failing its check, or failing that, the next step that reaches the most, with a button that previews it.
The detail panel called a node green "Reached" and, underneath in muted grey, "Configured, never verified". That gap between configured and working is the product's argument, so it is now the panel's first block: amber for never checked, red for failing, with ambit verify as the one filled button. The header's status takes the same colour, so green means something proved it. The outage sentence is body size, with its count in red. My Setup opened on "28 of 28 entries enabled" over a column reading "Enabled" on every row; it now opens on the entries that provide a failing capability and the servers that are enabled and put nothing on the map, and each row says whether what it provides has been checked. Time & cost leads with the saving in its largest type and the opportunity that pays back soonest, and a capability configured and not working is an alert across the page above the figures.
The demo contradicted itself. Time & cost reported 38 checks passing and "E2E on Edge" failing, over a map on which nothing had ever been checked and no node had that name. npm run demo:generate now runs the fixture's checks through the engine's own runner, with true and false standing in for real commands as the fixture stands in for a real config, and the loop snapshot reads its evidence counts off that tree. Two reached nodes are left unchecked, so the demo can show the state the panel exists to flag.
unlockCascade credited a next step with everything reachable from anywhere. On the demo tree six unrelated next steps each "made 18 more capabilities reachable", the same 18, and the unlock simulation lit all of them. It now counts only what depends on the node: Model Routing reaches six, Embeddings four, and three reach nothing on their own.
The link cards were a brand: the tagline beside a graph of coloured dots, naming no tool a reader uses, and every docs page shared it. The home card now asks what breaks if one MCP server goes down, names the runtimes Ambit reads, and draws one node down and the six that go with it. Each docs page has its own card, generated from a one-line reason to open it that build-docs.ts keeps beside the page's title, and carries its own image, dimensions and alt text.
#The hosted site says what it is, in text a crawler can read
An audit of the hosted site found a single URL with about two hundred words on it, rendered by JavaScript, while everything quotable lived on GitHub. The documentation is now published there as static pages under /ambit/docs/: the guide, the FAQ, the reference, the argument and its theory, the roadmap, security, contributing, the changelog, and a new page on Ambit and Jev. Each has its own title, description and canonical URL, heading anchors that match GitHub's, and system fonts so nothing blocks it. Links between documents stay on the site, images are copied beside the pages, and anything else points at the file on GitHub. A test builds the whole set and fails on any internal link or anchor that does not resolve.
The sitemap is generated from the same list, so it holds the home page and the published pages and nothing else. It used to list ?demo=1 views of a page that names the home page as its canonical, which told a crawler two contradictory things. The landing page carries a static summary with links into the docs for anything that does not run JavaScript, hidden before the app mounts so no reader sees it flash. Its title and description lead with what people search for, its structured data carries the released version, author and repository, and its fonts no longer block the first paint.
The welcome screen moved on phones. Its hero was centred with align-items, and a flex item taller than its container overflows at both ends, so when web fonts arrived and it grew, it grew upward under the reader. Auto margins centre it when it fits and top-align it when it does not. Fonts load with display=optional, so text never re-flows. The hosted demo stopped asking GitHub Pages for /api/health, which logged a 404 on every visit, and the primary button's white text now clears contrast.
#Jev on the map, and kept off the authority path
TypeSafe's Jev, a model that answers typed questions with calibrated probabilities instead of text, reached a large share of agent stacks within days of its release, and every one of its MCP servers landed on the map as an unmapped tool server. The curated tree has two new nodes. Typed Judgment, in Model Access, is reached by Jev through its API, an MCP server, or an open clone serving the same endpoint. Local Typed Judgment, in Sovereignty, is reached by a clone on the machine's own hardware, which is the version that keeps the judged state off a third party's servers. Local Typed Judgment has a declared check: it sends one trivial question to a clone on the loopback ports Kev and OpenJev use, or to TYPESAFE_BASE_URL or JEV_BASE_URL when either names this machine, and passes when judgments come back. It never contacts any other host, and refuses a URL carrying userinfo, which curl would otherwise read as a request to whatever follows the @. Typed Judgment has none, because proving the hosted API answers means spending the person's key on a call they did not type.
ambit goal "<sentence>" --judge closes the gap the roadmap named for goal routing: a goal that names none of the tree's words had no route in. When the vocabulary cannot recommend, the sentence goes to a judgment model on this machine as one Choice over every node, and the answer comes back as a suggestion with its probability, or as the three likeliest when none reaches even odds. It writes nothing. It asks only a URL that parses as loopback with no credentials, because the goal is the person's own words and a prefix test would pass http://127.0.0.1:1@host; it defaults to Kev on 127.0.0.1:8009, and a goal the words already cover opens no socket. It is the fifth command that opens one, and the security invariants list it.
The docs say where Jev stops. It is a capability a runtime may consult before it asks ambit can, and never a substitute for the grant: a published test moved its probability of blocking a destructive command with injected text, and a grant a person set in advance has no such input. The hosted demo and the README examples carry a Jev server, so both show the node reached.
#Authority for a window, a tree you can extend, and a decision that reaches you
A standing grant was permanent confirmation or permanent autonomy, so a person pairing closely with an agent for an afternoon either confirmed every command or granted autonomy for good. ambit authority grant <cap> autonomous --ttl=30m grants it for the window and no longer. Expiry is read at decision time and never written: an expired grant decides nothing, and whatever stood before it decides again, a standing confirm as confirm and nothing at all as a refusal. The first cut had an expired grant fall back to confirmation, which meant a row that had ended kept buying something forever; the test that encoded it is the test that now forbids it. A forbidden grant takes no TTL, for the reason a threshold does not, and --by names who declared the grant, as it does for promote and sandbox, without binding the grant to them.
The curated tree is general software development, and a team whose capabilities have other names had nowhere to put them. .ambit/techtree.json in the working directory, or AMBIT_OVERLAY_TECHTREE, is merged over the curated tree before seeding: a new id is a new node with its contract and prerequisites, an existing id extends the curated node's detection and requirements, and override: true replaces it. An overlay is data like the tree it extends.
An agent that drafts a proposal while the person is away from the machine used to wait. ambit dispatch <id>, or --dispatch on propose and approve, pushes the draft to a Slack, Discord or Telegram webhook, an ntfy topic, or any JSON endpoint named by --to or AMBIT_APPROVAL_WEBHOOK: the goal, the cost, what it unlocks and the commands that decide it; once approved, the signed artifact, so what the phone shows is what apply will verify. The channel is one-way on purpose. Nothing that arrives on a webhook mints an approval; the reply comes back through ambit approve on a machine that holds the key, and a chat is not one. Nothing is sent without a URL, and the four commands that open a socket are listed in the security invariants.
The infrastructure scan reads the local Docker socket when there is one, with a single read-only request, so running containers appear beside the manifest's services on a device:docker node, with their image, state and ports. No socket is a quiet absence; a socket file with a stopped engine behind it is a warning. Four capabilities gained declared checks, each one command that reads and changes nothing: whether MCP servers can launch (npx or uvx), whether there is a client to query data with, whether a delivery CLI is present, and whether the mesh or the engine answers.
#The decision, both ways, and what an agent may do
The README promised approval in one click, and on every machine that had not declared a web actor by hand the click failed: the engine refuses a decision from a person the graph does not know, and nothing had declared the person at the browser. The API declares them on the way in now, once, as the person at this machine's loopback port. Refusal had no route at all, so a no made in the browser vanished and the record the next draft learns from was one-sided; the card has a Turn down button, an optional reason, and a Turned down tab, and the engine records who and why. Steps drafted by the engine, which are shaped {id, name, chosen}, printed as their own JSON on the card; they read as a name and what supplies it.
Authority is per action, and the panel said only the capability's own mode. It lists what the capability may do now, each action with whether it asks: read the output without asking, run a command with. What work asked for and never had, which reached the page as a fragility footnote, heads the queue of what to reach, with how many times it stopped work and whether the same cause recurred, since a capability that stopped work four times this week outranks one that would be neat to have. The ways to acquire a capability were a list; they are compared, cheapest first, cost as length on one scale, privacy as a tag, and the one the record of this person's decisions favours is marked, which is the same choice ambit propose would draft.
Two smaller things. A repository missing a server the global config has offers the entry ready to paste, composed by the endpoint that exists for exactly that; the entry still crosses into the config by the person's own hand. And the briefing an agent is given at connect, the MCP resource ambit://briefing, is a tab in My Setup, so what the agent believes about the machine can be read by the person it believes it about. Reading it applies any authority threshold the evidence now supports, as the resource and ambit briefing do, and does not mark the environment briefed. The detail panel says how long a capability's configuration has gone unchanged, once it is two weeks, which is the glossary's decay with its name on it.
#Every state carries its reason and its next move
An audit of the web app for what a person could decide from it found the screens strong on state and weak on why and so what. Reached, next step, blocked, passing and failing were all drawn; what stood behind each, and what to do about it, mostly lived in the terminal. Most of it was already computed.
The governance half had no web surface. The Time & cost page now has one: reached capabilities by whether they act without asking, ask first, or are forbidden, drawn as one bar in the assurance figure's three inks; the grants the engine says have earned a threshold nobody set, each with how often it was confirmed by hand, what passed, and the command that records a threshold, which stays a command because promotion needs a person; standing budgets as spend against ceiling; and sandboxes. The detail panel states the effective mode on every node that has one.
What to reach next is a ranked list with its reasons, the same three ambit next prints: what has blocked work and how often, what reaching each would also reach, and the setup time, with the basis named, observed or structural. The frontier was a set of outlined circles with a cost. The opportunities table keeps its own question, what would pay back, and is titled that.
A blocked node used to be a faded circle whose panel listed needs without saying which were unmet. The panel now says what it is blocked by, every hop up, and how long closing the gap would take; a third simulation draws the gap on the map in amber. Each era's header carries the setup time left to finish it.
The outage cascade painted everything downstream red, so losing one of two providers read the same as losing the only one. The tree payload carries each node's providers and each edge's kind now, and the simulation draws what stops in red and what only loses a provider in amber; the panel and the banner count both. The runtime, which contributes every entry read from its config, is no longer any entry's single point of failure in ambit status or on the page.
A proposal card showed the goal and the steps. Deciding needs four more things the engine had stored and never shown: what it would save, from the economic case; what it costs, from the steps; whether every step has an inverse, which is what ambit apply will run; what it unlocks, from the stored simulation; and how this person has decided on things like it, from the record of approvals and rejections. All five are on the card, and the demo's cards carry the same, written by hand like the rest of the demo.
Evidence says how many runs it rests on, "check passed, 12 of 12 runs", where it read the same for one run and for forty. Failures the runtime reported are classified by the engine and listed on the panel by cause, a 401 as permission, a missing binary as a tool, so "check failing" says why. My Setup's evidence column carries the same. And the week's movement, gained, emergent, lost and diminished, is a strip under the Time & cost title, where the ledger knows what became reachable without anything new providing it, which no per-component changelog can show.
#One map, one list, one count
The web app had two maps and a list of the same things, and the header counted a mixture of them. The tree was one map. My Setup was a second, the machine's entries drawn as nodes in domain columns with nearly every edge running to the runtime, which is a list drawn as a star. The capability list docked on the left was a third of the window, open by default, listing what whichever map already drew. The header pill read "42 of 60 reached" on a demo whose own welcome page said "15 of 33 on the tree", because it counted the entries in with the nodes; on a live machine the list said 170 and the map drew 39.
The map is the tree, and only the tree. My Setup is the list it always was, full width: one row per entry a config declares, with whether it is on, what the engine's check said, and the nodes on the map it provides, each a link onto the map. Repositories and infrastructure, which were tabs inside the side panel, are tabs here, since they are the other two things a machine has. The docked list is gone; Search, on the header and on /, finds anything by name and opens it where it lives, a node on the map or an entry in My Setup. The store holds one list for all of it: the engine's tree, which already carries the entries and the edges from each to the nodes it proves, merged by id with the config read-out, so an entry keeps the config's facts and gains the engine's evidence, and switching views never goes to the network.
The header counts one population per view. On the map it is three segments, reached, next step and blocked, each of them the same control as its legend key, so the count is also the way to see those nodes alone; the glossary calls next step and blocked the informative states, and they used to be absent from the number that led. In My Setup it is enabled of total, over entries.
Selecting a node used to light the whole connected component, both directions, every hop, so a keystone lit most of the map and needing and enabling read the same. One hop now, and apart: what the node needs in teal, what it enables in indigo, with the rest dimmed; hovering previews the same. The transitive answer is the simulation, and the detail panel states it before the button that draws it: "If this went down, 14 other capabilities would stop working." It used to offer ambit impact to copy into a terminal for a question the page could answer. The panel's one list of neighbours, each with an edge word, is two lists, Needs and Enables, keyed with the map's two colours. ambit verify stays a command, because a check executes.
Rows inside a column used to follow insertion order, so height meant nothing while the Docs said it showed how far up the tree something sat. Each column opens in state order, reached first, and a few barycenter sweeps pull every node toward the mean row of what it connects to; edges are curves that leave and arrive horizontally, so a bundle into one node fans instead of converging through everything between; a long name wraps onto two lines where it was cut at eighteen characters with an ellipsis. The Docs say what height means now, which is nothing on its own.
The Shared credentials lens coloured any node whose id contained github, docker, 1password or credential, a string match dressed as an analysis, on a map whose curated nodes never matched it. It is withdrawn; credentials are ambit credentials, the engine's report. The Attention lens is offered disabled, with the reason in its tooltip, until the ledger has recorded something to colour; it used to grey the map and lay a note over it. My Setup's domain columns were named Foundation, Pipeline, Guard and Fortress, none of which is a word the glossary or the detail panel uses, and Foundation is also the tree's first era; a graph without eras names its columns with the domain's own word.
Two figures were being drawn as measurements of nothing. Time & cost showed "0h saved, $0 a year" on a machine whose ledger held runs but no interventions; a saving is a difference between months, so the figure waits for an intervention or a second month and says so. "One provider away from lost" listed most of a machine, because a runtime contributes every entry read from its config and so is each one's single provider by construction; ambit status and the page exclude the runtime from that report, and ambit impact runtime:<name> still answers for the runtime itself.
Narrow screens open on My Setup unless the link names a view: at phone width the map is texture and the list is not. The hero recorder writes the README's two stills as well as the GIF, so the pictures of the product are made the way the product is.
#The map says less, and the panels say each thing once
An audit of the interface for marks and controls that repeat something already on screen, or explain nothing, found a dozen of them.
On the map, a next-step node wore two rings: the outlined circle the legend keys as Next step, and a second, wider one outside it that filled in proportion to a readiness fraction no surface defined. Above many of them sat an amber tag reading Boost, a word in no legend, glossary or document. Both are gone; the outline and the setup cost beside it stay, which is what the legend and the Docs overlay say a next step looks like. The tooltip no longer opens over the selected node, whose detail panel is already saying everything it would, and its last line now says what a click does: it opens that panel, where the simulation is a button. It used to promise that the click would run the simulation itself.
The zoom controls are one control shorter. The percentage reading is the button that returns to actual size, so the 1:1 button and the divider before it are gone, and the lens buttons dropped the small keycap after each name; the tooltips and the Shortcuts tab still carry the keys. The controls also stopped moving. They were sticky inside the scroller, and centring a node carried them off the left edge of the window; a left inset did not save them, because Chrome measures it from the scroller's padding edge and other engines from its border edge. They are laid over the map now and stay where they are.
The detail panel opened with three boxes before its first sentence: a tinted banner for keystone, a bordered one for the check, and a third around the config switch. Keystone and evidence are lines now. A Notes block that said "Not reached yet" under a header reading "Next step" is gone, and the one fact the header cannot carry, a node with no edges at all, is a sentence. The Details list no longer prints state, next, era, era name and a count of setup seconds, which are the status in the header, the column the node sits in, and the cost the map writes as "15m"; setup time is written the same way here. Beside each neighbour the panel said hard-dep or soft-dep, the one place the data model's words reached a reader; it says required, optional or enables. The two commands are lines with a copy control, not bordered rows.
The Proposals overlay lost its search box. A machine holds a handful of proposals at a time and the three status tabs are the filter; a search over five cards was a control that never earned its row.
The Docs overlay's three reference tabs used eleven class names that no rule defined, so "Click a node" ran straight into its explanation, the line samples for Required and Optional were empty spans, and the shortcut keys were styled inline. The rules exist now, and the rules that did exist, for two tables nothing rendered, are gone, along with the tokens nothing read: a copper spectrum, a type scale and a line-height scale no rule used. Reading the Map explained outlined circles twice, under "Solid vs outlined" and again under "The states", the second time mentioning a halo the map no longer draws; it is one section, in the legend's order. The glossary's entry for maturity pointed at a ring around each node that has not been drawn for two releases.
The Vite dev proxy follows AMBIT_API_PORT, the variable the API server already reads, so the two can move together when 3000 and 3001 are taken.
#One word per thing, defined where you meet it
An audit of the interface for house shorthand found five concepts with four names each. The circle whose prerequisites are met was Next step in the legend, one step away in the header, next in the glossary and the frontier in the README. The ● node was a Combo in the legend, a Possibility in the detail panel and a Tech tree node in the docs. The ◈ node was a Server, a Tool server and an MCP server. The panel on the left was List on its button, Capabilities on its tab and the console in the code. None of it was wrong, and all of it defeated the learning a reader had already done. There is one word for each now, and src/client/vocabulary.test.ts fails the build if a retired synonym reaches a user-facing string.
The glossary was a dictionary behind a button: twelve definitions, in no particular order, disconnected from the screen that raised the question — and its own overlay opened by saying "Nine terms carry all the meaning here". The count is read from the file now, the file is ordered the way a reader meets the terms, and the words carry their definitions with them: a dotted underline in the header and the detail panel opens a card with the same sentence ambit help <term> prints, and the map's legend keys and era headers — SVG, where a popover cannot go — say it in a tooltip. Six terms that were on screen and in no glossary were written: keystone, tool server, attention, proposal, and the two halves of required-versus-optional.
Keystone and bottleneck were one idea under two names counted two ways: the map marks three or more dependants, ambit status counts the combos a capability unlocks. The glossary now states both rules under one term rather than implying they agree, and ambit help matches a concept's whole text, so looking up either word finds it.
Reached was the word for an MCP server that is switched on: the detail panel read "Tool server · Reached" directly above a switch labelled "Enabled", two words for one fact, disagreeing. My Setup says Enabled and Disabled, which is what its statuses mean; the Tech Tree says Reached, Next step and Blocked, which is what the legend beside it says. The two filters that had the same five words a few pixels apart — one over the map, one over the list — now each say which they act on.
#The half of the product you could not get to
An audit of the web app for things that worked and could not be found turned up two kinds of problem: state the URL could carry and nothing could produce, and endpoints and actions with no control anywhere on screen.
Time & cost — where a person's hours went, what they cost, and what would pay back fastest — rendered only when the store held demo data, so the tab did not exist for anyone running Ambit on their own machine. GET /api/loop now composes it out of the reports the CLI already prints (status, attention, opportunities, roi) plus the one query none of them makes: hours in the loop month by month, annotated with the proposal that landed. A ledger with nothing in it says so and names the two telemetry bridges that fill it, rather than drawing a page of zeroes that reads as "your time costs nothing".
Every view was linkable and no link could be made. The address bar now follows the view — graph, selected node, lens, filter — and Share copies it. ?treeFilter= had been readable from a URL and settable from nowhere; it is a control over the map, and compact, which was in the accepted list and in no renderer, is gone: it fell through to "frameworks only", a filter that hid the graph and could only be reached by typing it.
The legend's keys were buttons that spotlight a kind of node, with nothing to say so — they carry the affordance now, and a row that says what clicking does and how to clear it. A node's tooltip says which simulation a click will run, because the unlock simulation lives on faded nodes that read as scenery. The map says when it is live, since it redraws itself whenever the graph is rebuilt elsewhere. The attention lens explains itself when there is nothing to colour.
/api/repos/scan and /api/infrastructure/scan had no caller in the client: the work was done on request and thrown away. Both are tabs in the side panel now. toggleMcpEnabled had no button, so the one edit the browser may make to a real config — enabled: true|false on an entry that already exists — was unreachable; it is a switch on an MCP node when an engine is behind the page. loadFromJSON had no drop target, so "what does this look like for my setup" meant cloning the repository; the welcome screen takes an opencode.json and maps it in the tab, uploading nothing.
Two things were broken rather than hidden. Every "Map" button on the opportunity table matched the row's id against three hardcoded strings and fell through to the same fallback node, so all three led to Wrangler; each row now names the capability it prices, and the button switches to the map with the unlock simulation running. The demo's attention counts were seeded into the store's initial state, so a live machine briefly coloured its map from the fixture.
#The docs say each thing once
The README had two install sections that named Homebrew, Codespaces and the MCP registration twice each, and a nine-bullet reference on delegation records sitting in what is otherwise an introduction; the install is one section now and the record reference moved to the deep dive. The deep dive carried five "real-world walkthrough" scenarios whose console output the engine has never printed — cascade risk: CRITICAL, Available Frontier: 142 capabilities — in a voice that belonged to a brochure; they are gone, and the three honest cases in the README stand. Its canvas section, written in set notation with glowing emerald green, is a paragraph on what the map may and may not touch. The roadmap's §12 and §13 were specifications of things since built, three thousand words of them, and are now the decisions each part made and why, with the deep dive as the reference; its status table stopped saying nothing promotes a capability on evidence and nothing records use, both of which have shipped. The why essay's postscript, which listed what existed as of a version that no longer does, points at the roadmap instead. CONTRIBUTING had its list of good first contributions twice and the security invariants a third time; once each now, with the invariants in the agent guide alone. Roughly five thousand words fewer, and no claim in any of them that another file contradicts.
#The front door shows measurements
The landing page drew four circles labelled LLM, MCP, Tool and Goal for a product whose whole claim is that it measures things. It now draws the two measurements the demo makes, from the demo's own example data and labelled as such: a year of a person's hours with the two acquisitions named beside the drops they caused, and seven eras as small multiples on one scale with the reached fraction beside each bar and the next step drawn hollow. The sparkline moved into a shared figures.tsx so the landing and the dashboard are one drawing hand, and its annotations — which the dashboard had been marking with an unlabelled tick — are now named, staggering onto a second row where two would overprint.
The map's era columns say Era 5 · 0 of 5 under the name with a three-pixel fraction bar, all seven on one scale so a short bar is a small era rather than a poorly filled one. The status pill draws the same fraction it states, where a green dot had stood for nothing. The dashboard's money column gained the scale header the other columns already had, the interruptions column names its unit, payback marks say mo, the assurance caption carries 38 of 49 proved · 78%, and acquisition options put the dollar figure first in a fixed column so two alternatives compare at a glance. The capability list's filled, bordered status pills — three encodings for a two-valued fact, sixty times over — became a dot and a word.
#The map looks like one product
The client had two palettes — the slate-and-indigo tokens, and a cyberpunk cyan/magenta/neon-green the tree painted its nodes with — and fifteen CSS classes that no rule defined, so the zoom controls, the toast, the small buttons, the dashboard's filter tabs and the sidebar toggle all rendered as browser defaults. Every kind of node now has one colour, read from App.css by the map, the detail panel and the docs alike; the missing rules exist; the favicon and the social card are drawn in the same indigo as the app. The landing page renders on its own, without a capability list reading "(0)" behind it. The time-and-cost view sits beside the capability list instead of under it. The lens switcher moved from the top bar onto the map it colours. The map opens fitted to the window, so the seventh era and the runtime column are on screen instead of past the edge; the first-run card sits top right instead of on the legend; the legend describes the view it is under. The proposals panel says "waiting for your approval" and "approve and sign" where it said "AWAITING OPERATOR RATIFICATION" and "Ratify & Sign Policy", and signs as the web surface rather than as the author. Muted text passes AA contrast, every control shows a focus ring, and motion respects the reduced-motion setting.
The README's line is now also the page title and description, the package description, the citation title, the agent guide's first sentence and the social card. Thirteen unreferenced brand PNGs and a byte-identical duplicate of the social preview are gone; npm run assets:generate draws the card and the favicon and nothing else, and the README screenshots are captured with the first-run guide off. ambit status draws its per-domain rows as bars, so the first-run report and the command print the same thing; bootstrap.sh no longer keeps its own copy of that rendering, nor a tt alias. The launch kit moved out of docs/ into .github/.
#The numbers are drawn, not narrated
The demo's Time & cost page said "Today: 43 interventions a month, 8.6h of your time, $2150/mo. After: 0.8h a month, saving $1935/mo. Pays back in 0.6 months" — five figures in a sentence, three times over, with no way to compare one row against the next except by holding them in your head. The figures have not changed. They are now on shared scales.
What to set up next is a table with a graphic in each cell: the hours as a dumbbell from where they would land to where they are, every row on one 0–9h axis drawn once in the header; the money recovered as a bar on one scale; the payback as a mark against the month it has to beat. The old payback bar filled in proportion to nothing at all.
The headline saving is drawn as the thing it is. Twelve months of hours run under it with January held as a dashed reference, and the shaded band between them sums to exactly the 41 hours the number claims. Two months carry the acquisition that caused the step down. The forecast tile shows 37 predicted against 41 spent on one axis, with the labels on separate baselines because the two marks sit closest together precisely when the forecast was good. Four status chips became one part-to-whole bar; green and red never share an edge, because under deuteranopia they are the same colour at ΔE 5.6, so the grey segment separates them and every segment carries a written label.
Interruptions worth removing and decisions worth keeping were two lists side by side, which put a gap through the middle of the comparison the section exists to make. One chart now, one hours axis, sorted, with the keeper in the recessive grey under a hatch that survives greyscale and forced-colors.
The attention lens on the map painted a magnitude in two hues split at an undocumented count of twenty, and its legend never mentioned it existed. It is one hue in four steps now, brighter with more, monotonic in luminance and each step clearing 3:1 against the canvas, with bins taken from the data and printed in the legend under the unit they count. Its demo data pointed at three nodes no fixture contains, so pressing 2 on the view the demo link opens dimmed the map and warmed nothing; the counts now name real capabilities and are the same four the Time & cost page prices, so the two surfaces read one ledger.
#One fact, written down once
An audit for redundancy turned up two defects and a set of places where the same rule had been copied until the copies disagreed.
Recording a spend against a capability with no budget created a budget with a ceiling of zero, so a single recorded cent refused every later spend for ever — through a row ambit budget did not list, because a report of standing budgets reasonably skips the ones with no ceiling. Spending where nothing was delegated is now an absence of a budget and says so.
ambit sync carried human interventions and not the work runs they hold a foreign key to, so every intervention was silently skipped on import and counted as skipped. Runs, capability use and outcomes now travel, which matters more since successful work became the evidence that earns authority: a rebuilt container was losing exactly the record that had been earning it.
The graph-summary query had five copies, two of them byte-identical inside the MCP server, and the visualiser's counted reached as not-locked where every other surface counted unlocked-or-active — agreeing only because a third state has never been added. There were four wordings of "the graph is not seeded" offering three different fixes, two identical intervention-kind vocabularies under different names, a third partial copy of the same list, and five copies of the default config mapping differing only in the two words before "{type} server". All of it now comes from src/engine/vocabulary.ts and one parameterised mapping builder.
The formatter dropped nested objects entirely, so ambit can printed six of its nine fields and the governing grant and per-target evidence were visible only with --json. Asking over MCP recorded the deficit behind a refusal and asking on the CLI did not, so the same question had different consequences depending on where it was asked. A sandbox and a standing budget both widen what runs without a person and neither appeared in ambit authority or ambit status. ambit goal warned about a conflict with the alternative a proposal would not choose. Deficits captured from a runtime attribute to the provider that failed, which the curriculum could never see, so they roll up to what the provider supplies. An unseeded graph made the MCP server move every tool's answer under a nested key, changing the typed surface's shape according to the state of a database; the notice now rides on the text half only.
The tracker plugin honoured only one of the two database environment variables and then fell back to the session's working directory, wrote without the busy timeout the engine sets for four concurrent writers, and omitted kind — so every combo it created was stored as a provider and was invisible to half the product. Seven dead files are gone: two plugin aliases that re-exported names the canonical files already re-export, two component shims of the same kind, and three unreferenced scripts, one of which wrote a fixture that no longer exists.
#What makes the loop widen, not just report
The previous entry gave an agent a way to notice a gap, name it and ask. Nothing in that made the environment more capable: an agent could be told no all week and end it exactly as able as it started. Nine changes to the part that decides whether anything comes of the asking.
A threshold now counts successful work as well as passing checks, so an environment where the job succeeds daily stops having to run synthetic self-tests to earn trust it has already demonstrated. A failed run still counts against nothing, because attributing a run's outcome to every capability it touched would demote whatever a bad afternoon went near.
ambit authority promote with no arguments now names the grants that have earned a threshold nobody set. The interruption a threshold would end is exactly what stops anyone noticing it could, so the graph says it rather than waiting to be asked.
Scope decides. Two rules, in order: a forbidden grant wins outright at any specificity, and among the rest the most specific covering scope governs. Under narrowest-wins alone a grant saying "autonomous on staging" could never beat a standing "confirm everywhere", which made the only trade anyone actually wants inexpressible. --scope on a promotion writes that grant and leaves the standing one untouched. ambit authority sandbox declares somewhere acting does not matter, which is where a scoped threshold gets met cheaply; it relaxes confirmation and never a refusal.
ambit budget set <cap> --amount=$20 --by=<person> grants standing spend. Budgets existed and could only be written by the code that recorded spend, so the ceiling was real and the delegation was not.
ambit reject <id> <person> "why" records the half of every decision that used to vanish. ambit preferences --observed reads both halves, and ambit propose drafts the alternative the record favours and says why. A trait needs three decisions to count, and one that has gone both ways reads as contested rather than settled by majority.
ambit proposals --pending and the approval push carry the decision rather than announcing that one exists, and ambit approve takes several ids and one name. Every acquisition costs one interruption; a week of drafts read together is one sitting.
ambit reversible publishes what could be acquired without a person and what could not, which is the same list read backwards. ambit objects <target> and ambit verify --target= give authority and evidence an object, so committing to one repository forty times stops being a claim about the next one.
Five more MCP tools, twenty-two more tests.
#Ambit reaches the agent at the moment friction happens
Every command until now waited to be asked, which is no use to the agent that hits a missing binary mid-task, works around it, and hits the same one next week.
ambit briefing, served to a client on connect as the MCP resource ambit://briefing, says what is reached and proven, what is configured but failing, what is waiting on a person, what blocked work in the last week, and what is worth reaching next — prose, capped near 1,200 tokens, trimmed from the bottom because the order is the order of usefulness.
The ledger fills itself. The telemetry bridge reports failed tool executions and the engine classifies them from the signals a runtime states outright — a shell's message for a missing binary, EACCES, ECONNREFUSED, a 401, an MCP error kind — into the classes the deficit reports already used. A failure that only means work went wrong is left alone; one that cannot be attributed to any capability is kept and named, because that is a gap in the model rather than in the environment.
ambit_can now answers yes, ask or no with a sentence a person can act on, and files the deficit itself on a refusal, so asking before an unfamiliar tool costs one round trip rather than two. The README and llms.txt carry the two lines that make it a habit.
ambit next answers what to reach next and why — by what has actually blocked work once the ledger has observations, by leverage per hour of setup before then, and it says which. ambit record skill:<name> --provides= --verify= puts a skill the agent wrote on the map, refusing any registration without a read-only check and running it on the way in. ambit authority promote <cap> <action> --after=N --by=<person> is the person saying stop asking me once this has proved itself: the grant widens when the evidence arrives and narrows on a single failing check, with nobody asked. ambit sync export|import moves the graph and the ledger between machines, carrying no commands and no grants, so a rebuilt container gets its history back without importing someone else's permissions.
Seven MCP tools and one resource; twenty-seven new tests. The remaining piece is the npm publish, which is why every path in still starts with a checkout.
#The rest
- Every query names its row.
src/engine/rows.tsdeclares what a row of each table looks like, matchingschema.sqlplus the columnsmigrate.tsadds, and the handle'sallandgettake that type at the call. Sixty-odd reads that used to cast toanynow say which columns they select, which is how the compiler found a report reading agoal_idcolumn the proposals table does not have, and an intervention with no capability being used as a map key. - The client store is
ambitStore.ts. The guide said so; the file was a 12-line re-export oftoolchainStore.ts. The names now match the guide, the demo fixtures live instore/demo.tsso the store reads as the product's state rather than its sample data, and the old name stays as a shim. App.tsxis a shell. The viewport, hotkeys, first-run guide, toast, and the AG-UI stream are hooks; the top bar, welcome screen, guide card, and toast are components; the URL rule is a pure function the demo-landing test imports instead of copying. Two hundred and sixty lines where there were seven hundred, and the stream and key listener mount once instead of re-binding on every render.- The API server lives at
src/server/api.ts, beside its config, scanners, and tests, rather than at the repository root. - The roadmap opens with a status table: eleven sections, what each has built, and what each still lacks, so a reader does not have to find the "unbuilt" paragraph eleven times.
- Getting to a first run is shorter. The README opens with a four-row "try it" block (hosted demo, Homebrew, Codespaces, MCP registration), Homebrew is documented as an install path for the first time even though the tap has shipped every release, and a
.devcontainerseeds a graph and starts the map so Codespaces is a one-click checkout.ambit webno longer insists on Bun, which nothing else in the repository needs. New readers get a FAQ, aSUPPORT.md, a comparison table against tool-RAG, workflow graphs, and package managers, and anllms.txton the demo site for agents deciding whether to recommend the tool. Aserver.jsonandmcpNameare ready for the MCP registry once the npm package exists, and the launch kit lists the directories to submit to. A first issue or pull request gets a reply that says what CI will run. - The CLI groups forty-two commands under five nouns —
graph,plan,check,govern,report. Grouping is presentation, not a rename: every flat verb still dispatches, soambit impact xandambit graph impact xare the same command and nothing anyone has scripted stops working.ambit helpcovers a first session andambit help --allis the full surface. - The MCP server advertises each tool once. Every tool was listed twice, as
ambit_*and as the legacytt_*, sotools/listreturned 96 entries for 48 tools and spent about 3,600 tokens of every agent's context on duplicates. Att_name written before the rename still dispatches; it is no longer advertised. Results now carry MCPstructuredContentalongside the text block, so an agent reads a field rather than parsing a string. - An approval is only spendable on what it authorised.
verifyApprovalchecked that an artifact was intact, unexpired and signed by the recorded approver, and nothing else — so any approved proposal was a bearer token for any gated action, and an approval to install a linter would authorise a production deploy.approvalCoverscloses it: an approval is valid only for a capability that appears in the steps of the proposal that was approved. - CI measures coverage with a floor under it, and runs on Node 24 as well as 22.
- Autonomous Control Plane & Safety Interception: Active runtime interceptor (
src/control_plane/proxy.ts,src/control_plane/cli.ts) that enforces capability DAG prerequisites, lifecycle checks (degraded/broken), and authority policies before tool execution. AMBIT_BLOCKED_UNAUTHORIZED& State Invariance: Rogue or out-of-order agent tool executions (such as unapproved production rollouts) are blocked at the control plane boundary with exit code2, guaranteeingpre_state == post_state.- Human-in-the-Loop HMAC Remediation: Blocked executions generate structured remediation proposals and cryptographic HMAC challenges (
ambit approve <proposal-id> <person>), minting signed artifacts verified prior to state mutation. - OpenTelemetry Trace Instrumentation: Spans and structured event records capture DAG evaluations, missing authorization nodes, HMAC challenges, and verification receipts.
- Verified Incident Trace & Demonstration Suite:
- Published Incident Report:
docs/incidents/INCIDENT_TRACE_001.md - Automated suite:
src/control_plane/proxy.test.ts— eight cases in the suite CI actually runs, replacing four pytest cases that no job had ever executed. - 90-Second Reproducible Demonstration:
scripts/demo_incident_trace.py(demo:incident) anddocs/incidents/demo_intervention_trace.cast.
- Published Incident Report:
#0.4.1 — 2026-08-30
- Adoption and distribution hardening: current install instructions, Node-only CLI bootstrap, npm release automation, and the
ambitHomebrew command alias. - The npm package is prepared for publication with a compiled engine (
dist-cli/, built onprepack) and no runtime dependencies. It is not advertised as an install path untilambit-cliis actually published. A bareambitfrom Homebrew or a checkout seeds an empty graph before reporting instead of telling you to run a second command.--jsonruns on a cold graph stay pure JSON. ambit mcpruns the MCP server from an installed copy —claude mcp add ambit -- ambit mcpregisters the verified Homebrew command without knowing where Homebrew placed the package.ambit sharewrites a self-contained HTML snapshot of the map for posting wherever the person chooses — the file is built from an allow-list (name, kind, domain, era, state, lifecycle, edges), so commands, URLs, paths, descriptions, and economics cannot enter it; people render as "a person", and--redactreplaces every non-curated name with its category. Nothing is uploaded; writing the file locally is the whole command.- The agent loop closes for real, and the README shows it. The embeddings capability's local alternative now carries a declarative
config_patchand an authority declaration (execute: confirm), which makes it the first acquisition that runs the whole span: an agent records a deficit and drafts a proposal over MCP, a person approves and applies it, the graph re-seeds, and Local Embeddings unlocks through composition.scripts/demo-agent-loop.tsruns that loop against a fixture graph and renders the actual output asdocs/assets/agent-loop-demo.gif— a failing loop fails the recording rather than rendering a fiction. The propose note and MCP tool description no longer claim applying is unimplemented; they say whatambit applyactually refuses and why. - Evidence reaches the surfaces people actually look at.
ambit statusgains an evidence block — proven / unproven / failing counts, when a check last ran, and which unproven capabilities have a declared check waiting — and the map badges each reached capability: ✓ for a passing check, ! for a failing one, nothing for configured-but-unproven, with the detail panel saying it in words ("Check passed 2h ago" / "Configured — never verified"). The lifecycle machinery existed; it was visible only to someone who already knew to askambit verify --history. ambit weboutside a checkout explains that the visualizer needs one (and where the hosted demo is) instead of failing with bun's script-not-found.- First-run discovery now combines OpenCode, Claude Code, Cursor (
~/.cursor/mcp.json), Windsurf (~/.codeium/windsurf/mcp_config.json), Gemini CLI (~/.gemini/settings.json), Claude Desktop (its platform config path), and Codex CLI (~/.codex/config.toml, read by a purpose-built reader for its[mcp_servers.*]tables rather than a TOML dependency). Shared MCP servers stay one capability with a contribution edge from each runtime. - The README no longer advertises the unpublished npm package; the release workflow will publish it automatically once
NPM_TOKENis configured. - Redundancy now accounts for what fails together. Providers presenting the same credential do not fail independently, so a capability with three of them was reported as robust — and, since having several providers is what kept it out of the single-point-of-failure report, excluded by the very fact that made it fragile. A
credentialsblock declares which providers share one,ambit impactcalls what survivesnominalrather thanredundant, andambit credentialsanswers what a revocation would end. Only a credential every provider presents counts; partial sharing leaves something standing and is not reported as fragile. No secret is read or stored — there is no field one could arrive in. - Commands whose answer is a list printed the note about the list and not the list.
ambit authorityshowed its per-row detail and omitted the four lists summarising it, on the surface the tool considers primary. - Capability, action, provider, resource, actor and runtime are now separate kinds of node, and
provides,contributes,requires,optional,authorizesandruns_onseparate kinds of edge. Redundancy analysis previously matched three English sentences to decide what supplied what, so an adapter phrasing one differently made a capability with two providers report as a single point of failure. - Ids are unchanged, so no ledger history is lost. Existing graphs migrate by adding columns and backfilling once;
ambit spof,ambit impact,ambit planandambit sincereturn identical output against a graph seeded by the previous version. - Capabilities can declare the concrete actions they confer. Ten do, and
ambit actions version-controlreports that reading the repository and committing may run unattended while pushing a branch and merging to the default branch may not — a distinction the coarse node could not make. - Authority is a table with a source, and both adapters now pass through what their runtime states about itself: Hermes's
approvals.modeandapprovals.cron_mode, Claude Code'spermissions.defaultMode. Where the curated model and the runtime disagree the narrower wins, andambit authoritynames which one narrowed it. Nothing is enforced; Ambit describes authority. - Each capability carries a lifecycle — unknown, detected, configured, verified, reliable, degraded, broken — derived from its providers and its recorded evidence. A capability whose check has started failing reads as broken and stays in the frontier, because reachable and working are different claims — and it now gates:
ambit planrefuses to route through it,ambit simulatereports it asblocked_by_degraded,ambit authorityandambit actionsstop listing it as reachable,ambit nearsays re-verify rather than add, andambit statsreports it in a failing count. The ledger records demonstrated reliability beside reach: each snapshot carries a verified count and an id→lifecycle map, soambit sincereports a capability that stopped working as diminished while the structural frontier stays flat. ambit sincedistinguishes an expanding vocabulary from an expanding frontier. Upgrading to this version would otherwise have reported a dozen capabilities gained on a machine where nothing happened.- The engine is now modules named after what they do — discovery, inference, assurance, planning, governance, ledger — rather than one 1,864-line file.
- The graph an installed copy keeps now lives in
~/.local/share/ambit/graph.dbrather than inside the install directory, wherebrew upgradedeleted it. A checkout still keeps its graph in the checkout, and an existing graph is never moved.ambit whereprints the path. ambit seedandambit whereare documented inambit --help; the Homebrew and npm installs previously had no documented way to build a graph.- An unseeded graph now says so instead of answering every question with "Nothing to report". Over MCP it returns an explicit notice, so an agent cannot mistake not set up for an environment with no capabilities.
- The MCP server introduces itself as
ambitat the package version, rather thantech-treeat1.0.0. - CI runs typecheck, tests, build, and a bootstrap against a machine with no agent config. The demo deploys from CI.
#0.4.0 — 2026-08-13
Capability Graph became Ambit. The old name described the data structure; the new one describes the subject — what you, your agents and your machines can jointly do. Mostly a repair release: the previous version documented a tool that did not run, so the claims it already made had to become true before anything could be built on them.
See what your own agents can reach
Ambit reads the MCP configs of Claude Code, Cursor, OpenCode and thirteen more agents into one local map: every server, which ones work, what one more step would open, and what breaks if a piece goes.
Open the live demoa sample setup in your browser, nothing to install
On your machine: npx ambit-cli, with Node 22.18 or newer on macOS or Linux.
MIT licensed · one local SQLite file, no telemetry · on npm and in the official MCP registry