The autonomy loop
Every run cycles Plan → Act → Verify → Reflect → Remember. The agent decomposes the
goal into a live task plan it writes and ticks off as it works. Stall detection
notices when it is repeating itself — the same tool and arguments, steps with no file
change, repeated failing verifies — and forces a re-plan or asks for help instead of
grinding silently to the step limit. Plan-aware reflect refuses to declare victory
while steps remain outstanding.
Why it matters: it turns "wandered off and burned the budget"
into "noticed, corrected, finished". Grinding to a step limit is the single most common way
an autonomous run fails.
Memory that survives the session
Conventions, architecture notes, build/test/run commands, gotchas and past decisions are
learned into .akili-code/memory.json and folded into every later run's system
prompt.
Why it matters: the second run on a project starts already
knowing it — so every session makes the next one smarter and cheaper instead of
re-deriving the same project from scratch.
Sub-agents for the big jobs
A bounded chunk of a large task can be delegated to a focused worker with its own clean
context, sharing the same project, policy, cancel token and budget — with its usage and its
file writes folded back into the parent run.
Why it matters: the main context stays lean, which is what
keeps a long task coherent — and cheaper — instead of drowning in its own transcript.
Provable acceptance, not claims
For web work, a headless-browser check_page tool renders the URL the agent
just built — post-JavaScript — asserts the expected content is really there, and measures
numeric targets. For documents, check_doc re-opens the artifact and verifies
its sections and figures.
Why it matters: this is what makes "I built it and it works"
a checkable statement. The engine drives its own work and shows you the evidence.
Token economy as a first-class feature
Caching is credited honestly across every provider's own field convention — the largest of
prompt_tokens_details.cached_tokens (OpenAI, Kimi, GLM and newer DeepSeek),
cached_tokens (Moonshot's mirror) and prompt_cache_hit_tokens
(DeepSeek's classic field) — so no provider's savings go uncounted. On top of that: a live
context gauge, a session meter of actual input · output · cached tokens and cost
parsed from the API's own usage, a cache-savings readout, and a 📊 Usage dashboard
with a per-model cost breakdown.
Why it matters: cache hits are the difference between a long
agent session being affordable and being absurd — but providers report them in mutually
incompatible fields. Read one convention and two-thirds of your savings silently vanish.
Budgets that actually stop the run
Set a per-conversation cap and a per-day cap in dollars. The status is shown live, sending
is blocked at the limit, and the agent is hard-stopped mid-run when a cap is reached.
Prices use the upstream's peak rates, so the meter errs toward over-reporting.
Why it matters: a budget that stops the agent slightly early
is recoverable; one that overshoots is not. An autonomous agent you can't cap isn't one you
can leave running.
Bring your own model
Akili's own managed endpoint — Akili Fundi (Code) for agent runs and refactors,
Akili Core for chat and quick edits, both 1M context — or bring your own account
with a preset for Anthropic, OpenAI, Kimi (Moonshot) and
z.ai / GLM. Switch to a cheaper model mid-conversation and the context gauge and cost
meter re-scale to it. Any OpenAI-compatible endpoint works, and a loopback endpoint needs no
key at all.
Why it matters: start on the deep-reasoning model while the
thinking is hard, drop to the cheap one once it isn't. Your keys, your accounts, your
machine.
Trust rails you can't accidentally loosen
A policy engine disables whole tools or blocks command patterns; a denied call is refused
before it runs and the agent is told why, so it adapts instead of failing. Destructive
commands are blocked out of the box. A team policy committed to the repo merges
union with each user's policy — so a teammate's agent can only ever be
more restricted than your shared baseline, never less.
Why it matters: guardrails that a single user can quietly
weaken aren't guardrails. Safety that only ratchets one way is safety you can actually
standardize on.
