Everything Anvil actually does.

Everything Anvil remembers lives in an encrypted database (SQLCipher) on your own disk — nothing readable sits there in the clear. It matters because your working knowledge is sensitive: decisions, code, client details. Keeping it local and encrypted means it's yours, not a cloud vendor's, and a stolen laptop doesn't hand it over.

Before your assistant answers, Anvil automatically finds the relevant memories and feeds them in — you never have to ask "remember when we…". It matters because a memory you have to manually invoke isn't really a memory; auto-recall is what makes the assistant feel like it actually knows your project.

Facts, entities and the relationships between them are stored as a connected graph, not a pile of loose text. It matters because "the auth service owns the token table, which the billing job reads" is a relationship — storing it as structure lets Anvil reason across connections instead of keyword-matching blobs.

Search works by meaning, then re-ranks the best passages — so "why did the vault lock" finds the note that never uses the word "lock". It matters because you rarely remember the exact words you wrote; meaning-based recall finds the right thing anyway.

When a new fact clashes with something already stored, Anvil flags it and supersedes rather than silently deletes. It matters because a memory that quietly holds two opposite "truths" will confidently mislead you; catching the clash keeps the brain trustworthy.

Every grounded answer shows the exact memory rows it reasoned from — with their origin and how closely they matched. It matters because "trust me" isn't good enough for real work; you can inspect the sources and catch a weak one before you act on it.

You can expire memories automatically after a set time, or delete them for good — and Anvil proves nothing remains. It matters because not everything should live forever; some things are time-boxed, and some you simply have a right to erase.

See what Anvil knew, when it knew it, and where it came from — with rewind and versions. It matters because when an answer looks wrong, you can trace it back to the memory and moment that produced it instead of guessing.

Anvil scans its own store for duplicates, dangling links and stale facts, and compacts it for denser storage and faster recall. It matters because a brain that fills up with junk gets slow and unreliable; quiet self-maintenance keeps it healthy without you babysitting it.

Anvil distils your accumulated memories into reusable skills and hard rules automatically. It matters because lived experience shouldn't stay as scattered notes — turning "we always deploy this way" into a rule means the lesson actually gets applied next time.

On first run you can pull in Obsidian vaults, JSONL exports and your chat history so the brain starts full, not empty. It matters because your knowledge already exists somewhere; Anvil is far more useful on day one if it can read it in rather than starting from zero.

A compiled "read-first" briefing plus your always-on directives get injected into every session. It matters because there are things the assistant should know or obey every single time — this guarantees they're present without you re-pasting them.

Export and restore your whole brain — a real, passphrase-protected data-loss guard, including a recovery PDF. It matters because a memory you could lose in a disk failure isn't something you'll trust with important work; backups make it safe to rely on.

A session you never close — grown to tens of thousands of turns and compacted many times — gets folded into memory in full, never truncated. It matters because long-running work loses its tail today; distillation captures the whole thing so nothing said late in a marathon session is lost.

Point Anvil at Claude, GPT, a local NIM or Ollama — your own subscription or key. It matters because you shouldn't be locked to one vendor or pay twice; Anvil is the brain and memory, the model is a swappable part you choose.

Anthropic API, Claude-CLI, Codex-CLI, Google, Ollama and any OpenAI-compatible endpoint are all supported. It matters because your best or cheapest option changes over time and by task; supporting many transports means you're never boxed in.

Different jobs — orchestrator, worker, verifier, vision, offline — can run on different engines. It matters because one model rarely wins at everything; letting a cheap fast model do the grunt work while a stronger one verifies gets you better results for less.

Non-trivial output is checked by a second, independent pass before it's trusted — a separate role whose only job is to catch the first one's mistakes. It matters because a model grading its own homework misses its own blind spots; an independent check is what turns "sounds right" into "is right".

Anvil routes across providers and fails over automatically with cooldowns when one is down or rate-limited. It matters because a single provider will eventually hiccup; automatic failover keeps you working instead of stopping to fix config.

Run entirely on local models (MLX and Ollama) with no internet at all. It matters because sometimes you're offline, air-gapped, or simply don't want a prompt leaving the building — local models keep Anvil working anyway.

See exactly which provider is capped and for how long. It matters because being silently throttled mid-task is maddening; showing the cap means you understand a slowdown instead of guessing something broke.

Exact token and cost accounting per task, with budgets per role. It matters because AI spend hides in a hundred small calls; seeing it per task keeps surprises off your bill.

Choose how much latitude the assistant has — plan, manual, accept-edits, auto, or bypass. It matters because trust is earned gradually; you can keep a tight leash on risky work and loosen it where you're comfortable.

A vision role exists; the input pathway to feed it images is being built. It matters because a lot of real context is visual — a screenshot of an error, a diagram — and being able to hand that to the model closes a real gap.

A library of expert playbooks — git, security, architecture, testing, debugging, shipping and more — the assistant draws on automatically. It matters because it stops a capable model from shipping confident slop; the skills are the good habits that turn raw capability into dependable work.

Skills are selected by intent — trigger phrases and meaning — so the right procedure surfaces when it's relevant. It matters because a skill nobody remembers to use is dead weight; automatic selection means expertise shows up exactly when the task calls for it.

A repeated error becomes a hard rule the assistant can't cross. It matters because the most expensive bugs are the ones you make twice; turning a lesson into a guardrail means it genuinely stops happening.

Write, import, lint and version your own skills, plus the full Pro skill set. It matters because your team has its own conventions and hard-won know-how; capturing them as skills makes the assistant work the way you actually work.

Search skills by name and contents, scaling to thousands. It matters because a big library is only useful if you can find the right skill fast — otherwise it becomes clutter.

Add new skills live, without restarting. It matters because momentum dies when you have to stop and reboot to try a new procedure; hot-loading keeps you in flow.

New and updated official skills can arrive between app releases, each cryptographically signed and verified against a baked key before it loads — fail-closed, so an unsigned skill never runs. It matters because your expert playbooks shouldn't be frozen until the next version ships; the signing is what makes live delivery safe rather than a supply-chain hole.

Embers are personas built from a character crossed with a real skill — a skeptic who's also a security engineer, say — and you direct who's in the room. It matters because a single model answering alone tends to agree with itself; distinct, fused voices surface angles one pass would miss.

Anvil seats a starting panel and grows it on demand as new angles surface — pulling in the right specialist when, say, a compliance question appears. It matters because you don't know in advance which experts a hard decision needs; the room adapts to the problem.

A driver voice can push hard, but a compliance or security voice can veto — and only when the risk is grounded in fact, not vibes. It matters because you want ambition and a real check on it; the veto only bites when the exposure is genuine, so it can't be used to shut down every idea.

Run it to reconcile every voice into one best answer, or debate to a chair who rules. It matters because different decisions want different endings — sometimes consensus, sometimes a decisive call — and you pick.

Save a room you like, reuse it, and replay past debates. It matters because a good panel is worth keeping, and being able to revisit how a decision was argued is often as valuable as the decision itself.

Compress a long debate or working session into durable memory. It matters because the insight from a big discussion shouldn't evaporate when the window closes; folding it in keeps the conclusion available later.

Let spent voices step out so the room can seat more distinct angles than one context window holds. It matters because a fixed panel caps how many perspectives a debate can cover; retiring contributors as they finish lets a single debate span far more expertise.

Assign different Embers to different providers, so the voices are genuinely independent minds. It matters because real disagreement is stronger when the debaters aren't all the same model wearing hats — different engines decorrelate the thinking.

Keys and sensitive material sit in an encrypted vault; the keys themselves never travel into the model's context. It matters because the fastest way to leak a secret is to let it ride along in a prompt — the vault keeps it sealed and separate.

Your API keys and credentials are stored sealed and kept out of prompts on a best-effort basis. It matters because you need those keys available to the tools but never pasted into a chat that goes to a third party.

Anvil scrubs API keys and tokens before anything leaves your machine, and shows you a preview of what gets redacted. It matters because secrets slip into text by accident constantly; catching them at the door is a real safety net (best-effort, not a DLP guarantee).

Your memories and skills are guarded so a crafted prompt can't trick the assistant into exfiltrating them. It matters because your accumulated knowledge is the valuable part; ringfencing stops it being coaxed out through the model.

Anvil runs as a small always-on service talking over a local socket / named pipe — no inbound ports opened. It matters because the smallest attack surface is one that isn't exposed to the network at all.

Diagnostics and logs record what happened by reference, never the actual content you were working on. It matters because logs are a classic quiet leak; keeping them content-free means turning on diagnostics never exposes your work.

Nothing an autonomous pass proposes can ground a future turn until you approve it. It matters because you want the machine to suggest, not to quietly promote its own guesses into "facts" — the gate keeps a human in the loop on what becomes truth.

If a key is lost, a recovery path (and a printable recovery PDF) gets you back in. It matters because strong encryption is a double-edged sword — without recovery, one lost key means your whole brain is gone.

Touch ID and Windows Hello to unlock the vault. It matters because security you'll actually use has to be low-friction; biometric unlock beats retyping a passphrase all day.

A tamper-proof, encrypted log making every action accountable. It matters because teams and regulated environments need to prove who did what and when — an audit trail is the difference between "we think" and "we can show".

A Rules-of-Engagement gate, then a staged recon → map → hunt → prove → report workflow that routes to the right specialist playbook. It matters because ad-hoc poking both misses things and crosses lines; a gated, staged engagement keeps a security review thorough and authorized.

Focused hunting procedures for broken access control (IDOR/BOLA), authentication & tokens (JWT, OAuth, session, MFA), client & web (XSS, CORS, CSRF, clickjacking), injection (SQL/NoSQL, command, template, XXE), LLM app-security (prompt injection, tool abuse, RAG poisoning), and SSRF & infrastructure. It matters because real vulnerabilities hide in specific patterns; each playbook is the checklist a specialist would actually run.

A seven-question test plus a VRT/CVSS severity rubric that every finding must pass before it's written up. It matters because a tool that cries wolf is worse than none; the gate kills false positives before they waste anyone's time and keeps severities honest.

Capture proof for a finding, redact your own session secrets and other people's PII, and write it up impact-first. It matters because an unproven or leaky report is a liability; disciplined evidence is what makes a finding actionable and safe to share.

Map trust boundaries and data flows, work through STRIDE and attack trees, and rank by real risk. It matters because the cheapest bug to fix is the one you design out; threat modeling catches design flaws no scanner or code review will.

Anvil runs the range against its own surfaces — the MCP bridge, the Tauri shell, token custody and the memory store. It matters because a tool that holds your keys and your memory has to prove its own house is in order; this is Anvil auditing Anvil, and the pass has already closed real findings.

A first-class task board — add, list, update, park and complete work with priorities. It matters because your assistant should manage the actual work, not just answer questions; tasks live next to the memory that informs them.

A live map of what your system is actually made of — components and how they connect. It matters because architecture drifts from the docs the moment code changes; a blueprint drawn from reality keeps everyone honest about what really exists.

Phases, milestones and what's gating what, laid over your live tasks. It matters because a task board tells you what's open, but not the strategic shape — the roadmap shows the sequence and the dependencies.

Capture a URL to research in one tap. It matters because good ideas arrive mid-task; a quick capture means you don't lose them or derail to chase them right now.

A drag-and-drop board driven live off the daemon's event stream. It matters because a board that updates as the work does — not on refresh — is one you can actually trust at a glance.

Bundle a project's tasks and structure for sharing or archiving. It matters because your project data should be portable, not trapped — you can take it with you.

Two-way sync with Jira, Linear and GitHub. It matters because your team may already live in another tracker; syncing means Anvil fits your workflow instead of asking you to abandon it.

Dashboards, dependencies, ownership and burn-up charts. It matters because as projects grow you need the birds-eye view — where things are stuck, who owns what, and whether you'll land on time.

Every memory and skill is a star in a 3D galaxy you can fly through. It matters because a brain you can see is a brain you can trust and explore — it turns an abstract store into something you can actually navigate and understand at a glance.

Watch providers, roles and skills fire in real time as the assistant works. It matters because when AI is a black box you can't tell insight from guess; seeing the flow live tells you what's actually happening under the hood.

Flip providers, roles and skills on and off on the fly. It matters because control should be immediate — you can steer the machine's setup in the moment instead of editing config files and restarting.

A chat surface with live status stages, tokens-per-second and syntax highlighting. It matters because it's a convenience, not the main event — Anvil drives the AI app you already use, and the dock is there when you want it directly.

180+ commands — every surface is scriptable from the terminal. It matters because power users and automation live in the CLI; parity means nothing is trapped behind the GUI.

One step wires Anvil into Claude Code, Codex or Cursor, with a guided first run. It matters because the value only lands once it's connected; making that a single, obvious step removes the biggest drop-off.

Guard, recall and write-back hooks mean grounding is injected on every prompt and lessons are captured at session end — the assistant can't "forget" to check its memory. It matters because a memory the assistant might skip isn't reliable; the hooks make it automatic.

22 assistant tools exposed over the Model Context Protocol. It matters because MCP is how modern assistants call tools; the bridge lets any MCP-capable app use Anvil's memory and reasoning natively.

One-glance system health, status and housekeeping. It matters because an always-on service should tell you plainly when something's off, not leave you diagnosing silence.

Set local cron-style jobs that run a reasoning turn on a schedule. It matters because some work is recurring — a daily summary, a weekly review — and it should just happen without you kicking it off.

Distil, consolidate, enrich, back up and reap stale data — quietly, on a schedule. It matters because a brain needs upkeep to stay sharp; doing it in the background means you get the benefit without the chore.

A reasoning turn can go fetch its own data mid-thought. It matters because real answers often need a lookup partway through; letting the turn gather what it needs beats stopping to hand it context.

Anvil can reach logged-in pages (via Playwright) when research needs it. It matters because a lot of the useful web sits behind a login; being able to read it makes research actually complete.

After repeated failed attempts it stops and escalates instead of looping forever. It matters because a stuck agent burning tokens on the same failure is worse than useless; the breaker fails safe and asks for help.

The assistant can run only an allowlisted, compacted set of shell commands. It matters because shell access is powerful and dangerous; an allowlist gives you the usefulness without handing over the keys to the machine.

Your plan is a small signed token verified entirely on your device — activate with one command, no phone-home to use the app. It matters because your software shouldn't stop working when a licence server is down or you're offline.

A lapsed licence or downed provider drops you a rung — to Free — but never deletes your memory or locks you out. It matters because you should never be held hostage by a billing hiccup; your data and a working tool remain yours regardless.

Anvil won't dress up a guess as a verified fact. It matters because a confident wrong answer is more dangerous than an honest "I'm not sure" — knowing which is which is what makes it safe to rely on.

It can't self-approve risky changes; you gate them. It matters because autonomy without a ceiling is how automated systems cause real damage — the cap keeps a human on the irreversible calls.

Offline tokens stay revocable via a periodic check-in — a backstop against abuse and chargebacks. It matters because offline licences are convenient but need a way to be pulled if misused, without breaking the offline-first promise for honest users.

A central, encrypted brain the whole team shares. It matters because a team's knowledge shouldn't live in one person's laptop; a shared brain means the whole crew builds on the same memory.

Cedar-powered read / change / admin roles. It matters because once a brain is shared, not everyone should be able to do everything — roles keep access appropriate and auditable.

Single sign-on, directory integration and central administration. It matters because companies need to provision and de-provision people through the systems they already run — not a separate island.

Installed from a Homebrew tap of pre-built, signed tarballs. It matters because a clean, one-command install on the platform most developers use lowers the barrier to trying it.

Runs natively on Windows over named pipes — no WSL required. It matters because forcing Windows users into a Linux subsystem is friction and a support headache; native support means it just works.

Ships as a .deb / AppImage with a systemd service. It matters because Linux is home for many developers and servers; first-class packaging makes it a proper citizen there.

Generate images locally by default (MLX), with cloud opt-in. It matters because on-device generation keeps prompts and outputs private and free of per-image fees — you opt into the cloud only when you want to.

A passphrase-encrypted snapshot of your whole Anvil install, portable and restorable. It matters because moving machines or recovering from a failure should be one command, not a reconstruction project.

Registrations are tracked and fully purgeable. It matters because software that won't cleanly remove itself erodes trust; Anvil leaves no mess if you decide to go.

Bring your existing setup across in one step. It matters because switching tools is painful; making migration easy removes the reason to stay stuck on something worse.

Run Anvil headless, bring-your-own, with no GUI. It matters because servers and power users need it to run unattended — and a Claude-less, fully self-hosted path means you're never dead-ended.