Ambit glossary
Every word the map, the CLI and the MCP server use, defined once. The same file is what the app’s Docs overlay, its term popovers and ambit help <term> read, so a definition here is the one the interface shows.
#Ambit
What you, your agents and your machines can jointly do. Your ambit is everything your setup can actually do, which is more than any config file says, since capabilities compose from pieces configured separately. Ambit maps it, shows what one more step would open, and checks that what is there works and may run.
#Capability
One thing your agent setup can do. Every MCP server, agent, skill, provider, model and command in your config becomes a capability. So do the nodes of the curated tech tree. A capability is the unit everything else is measured against.
#Era
How far up the tree a capability sits. The tech tree runs through nine eras. Seven are the agent setup: Foundation, Model Access, Tool Use, Memory, Autonomy, Assurance, Sovereignty. Two are the product it builds: Product and Operations. Later eras depend on earlier ones — you cannot run fully offline before you have a local runtime. Eras describe ordering, not importance.
#Reached, next step, blocked
Where you are on a tech tree node. Reached: something in your config provides this and its required prerequisites are reached, and the graph records which entry provides it. Whether it works is a separate question, which its check answers. Next step: every required prerequisite is reached but nothing in your config provides it yet. These sit just past the frontier, and `ambit next` ranks them. Blocked: you have the tooling but a prerequisite is missing, e.g. retrieval configured with no vector store. Blocked is usually the most informative of the three.
#Required vs optional prerequisite
Whether a dependency gates a capability, or only helps. A required prerequisite must be in place or the dependent capability cannot work — a model cannot run without its provider. An optional one strengthens something without gating it. Only required prerequisites block a node from being reached; both are drawn, with optional ones fainter. The data model and the CLI call these hard and soft.
#Deficit
Work was blocked on it while it was missing. Each time an agent records that a task stopped for want of a capability, that capability's deficit count goes up. The map draws the count as Asked for: a next step filled from the inside, full at three. At three, Ambit calls the gap structural, since it has the same cause every time and needs something new. `ambit next` ranks by these counts before it ranks by leverage, `ambit deficits` lists them, and the Time & cost page shows them under What to reach next.
#Keystone
A capability many others depend on. Counted by how many capabilities would be affected if it disappeared: the map marks a node that three or more depend on. High-leverage to invest in, and risky to leave unmaintained. `ambit impact <id>` shows exactly what falls over. `ambit status` counts a narrower thing under Bottlenecks, the combos a capability unlocks, so the two lists overlap without being identical.
#Combo
A capability several others unlock. The tech tree nodes are combos, which is why each one's id starts with `combo:`, and you can define your own in a `combos` block for things specific to your work. A combo is a judgment about what composes into something new, which is why the tool never invents one from your config.
#Tool server
A tool your agent can call. An MCP server, which is the protocol agents use to reach tools. Everything the server exposes — reading a file, opening a page, querying a database — becomes something the agent can do, which is why one server switched off can take a row of capabilities with it.
#Carry weight
What a tool list costs in context, every session. A runtime loads every tool's name, description and input schema into the model's context at the start of each session, whether or not any of them is called. `ambit weigh` starts each local tool server your configs declare, asks for its tools and records the size, estimated at four characters a token. Each runtime carries its own servers, so the total is per runtime. A runtime that defers tool definitions until they are searched for carries less. Remote servers are not contacted, and a server never weighed shows no figure, which is not a weight of zero.
#Verified
Its declared check passed, not just configured. Detection proves a name appears in a config file. Verification runs a declared read-only check and records the result, so a capability can be said to pass its own check, not merely exist; the claim is as strong as what the check tests. Reliability is the share of recorded runs that passed, which is why the history is kept: one success is a weaker claim than forty-seven of fifty. Checks execute, so they live in the repository and run only when asked, never on seed.
#Recovering
Its last check passed after recent ones failed. The latest check decides, so a recovering capability counts as usable again: plans, the gate and the next steps treat it as working. It is not called verified until its recent runs stop failing, so every summary counts it with the unverified, and a surface that names it says how its recent runs went, as in "2 of the last 5 passed".
#Maturity
A 0-1 estimate of how established a capability is. Seeded from what kind of thing it is and whether it is enabled, then adjusted as your config changes. It is a rough ordering signal, not a measurement — treat a 0.8 as 'more settled than a 0.5', not as a score that means anything on its own.
#Lens
A way of colouring the map, which changes nothing on it. Standard colours each node by its state and its checks. Attention shades it by how often a person had to step in for it, and Authority by what it may do without asking. A lens repaints the map and leaves every node, edge and count where it was. A lens with nothing recorded behind it is offered switched off, with the reason.
#Domain
The area of work a capability belongs to. infra, devops, backend, frontend, ai-ml, quality, security, or meta. Inferred from the capability's name, which means a stack unlike the keyword table's assumptions will land more things in the meta fallback — that table is the first thing to edit.
#Attention
Time you spent stepping in so an agent could continue. Every recorded moment where a person had to step in — approve, correct, copy something across — priced at what an hour of your time is worth. The Attention lens shades the map by how often each capability demanded it; Time & cost ranks what removing it would save. Judgment and knowledge are never counted as reducible, however often they recur.
#Proposal
A change to your setup, drafted for a person to approve. An agent that finds a gap drafts a proposal rather than acting: the steps, their inverses, and what the frontier would look like afterwards. Approving it mints a signed artifact that expires; `ambit apply` verifies that signature before anything runs, and refuses if the proposal changed after approval.
#Authority
Whether it may run, not whether it can. Being technically able to perform an action is not permission to perform it. Authority is tracked separately per capability — observe and execute, each autonomous, confirm, or forbidden — so a reached capability can still require approval. A reached capability no grant names is refused until someone grants one, and the map says "no grant yet" apart from a refusal somebody wrote. This is what lets a larger technical surface stay governable: the limits are explicit rather than implied.
#Grant
A recorded decision about whether something may run. A grant names a capability, an action and a mode: runs without asking, asks first, or forbidden. It can be scoped to a target, held by one person or agent, or set to expire. A forbidden grant wins at any scope; otherwise the most specific grant that covers the question decides. The curated tree suggests a default, and a person's own grant takes its place.
#Threshold
How much evidence a person asks for before it stops asking. A person sets a threshold in advance: after this many passing checks and successful uses, the grant may widen from asking first to running without asking. The evidence alone never widens a grant, and one failing check narrows it again with no one asked.
#Ceiling
The most a capability may spend in a period. A spend ceiling is a budget a person sets on one capability and action, per day, week, month, quarter or year. The gate refuses a run that would go over it, and the figure forecasts where the period will land at the current pace. A ceiling bounds a grant and widens nothing.
#Joint capability
One the agent cannot supply alone. Some of what a setup can do exists only when a person or a machine takes part. The engine derives it from structure, not from names: a person who must approve a capability makes it institutional, one who supplies it makes it cognitive, a provider running on a device makes it physical, and a person and a machine supplying it together is the case where the ability sits in the loop and in neither half. A recurring acquisition cost is economic. The map marks the joint ones with a person or a device; the panel names who.
#Frontier
The edge of your ambit, as of a moment. The frontier is where your ambit ends. It covers everything reached, with the next steps just past it. Every seed records it, so the graph can answer what was reachable at a past date and not only now. `ambit history since` compares two of those observations. Its useful column is the emergent one. It lists the capabilities that became reachable although nothing providing them was added, which happens when prerequisites are satisfied by something else entirely. A per-component changelog cannot show those, because no single change explains one.
#Emergent
Reached although nothing new provides it. A capability becomes reachable when its last missing prerequisite is reached, which can happen without anything providing it being added. Those are emergent: no single change in a config explains one, which is why a changelog of components cannot show them.
#Diminished
Still reached, and no longer working. A capability that is still configured but whose last check now fails. It stays on the map as reached and is left out of every plan until a check passes again.
#Council
Five readings of the first step to reach. The step `ambit next` puts first, read by five seats, each from a question the engine already answers: Reach reads the frontier (what reaching it opens), What could break reads fragility (what it would rest on), Cost reads the ledger (what stepping in for it has cost, and whether it pays back), Permission reads authority (what it would be allowed to do once reached) and Checks reads the checks (whether its foundation is working). Each seat says one sentence, names the command behind it, and takes a stance; the panel says when they are split. A seat with nothing recorded to read says so and is marked silent. No seat runs anything.
#Decay
What you have stopped tending. `ambit decay` ranks capabilities by how long since their configuration last changed. It tracks configuration decisions, not how often you invoke something — a server you use daily but never reconfigure will look static, which is intentional. The question it answers is 'what have I stopped tending', not 'what do I use least'.
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