The rhythm is yours
Three moves, at whatever pace suits: every session, once a week, or only when something is worth keeping. Vant suggests a cadence, it never demands one.
Open the brain
A session begins by reading what earlier sessions left behind: identity, goals, lessons, errors. Whoever starts next arrives already knowing things.
$ vant migrate --status
$ vant startWork with memory
Learn facts as they happen. Search the corpus when context is missing instead of guessing.
$ vant learn deploy-gotcha "Freeze deploys during migration."
$ vant search "migration rollback steps"Keep what matters
Write lessons back, commit, push. Plain files in your repo, so the next session starts with everything. Skip a session and nothing breaks: the memory is files, it waits.
$ git add models/ && git commit -m "agent: session learnings"
$ git pushFive minutes to a first win
No dashboard to configure, no account to make. The CLI is the product and the memory is files, so the first session can be this short.
Install and start
One global install. vant start checks the brain layout, runs health checks, and imports any older single-brain layout it finds.
$ npm install -g vant
$ vant startMeet the brain
It is just markdown. Read it, edit it, keep your own notes in it. vant onboard walks the files for you.
$ vant onboard
$ cat models/private/vant/identity.mdWrite the first lesson
From here it just repeats: learn during the session, commit what is worth keeping, and the next session starts knowing it.
$ vant learn first-lesson "Vant works."
$ git add models/ && git commit -m "first lesson"Bringing your own agents
Any agent that can read a file or speak MCP can use Vant. Nothing vendor-specific to install.
The contract is a file
AGENTS.md in the repo root is the whole protocol: who the agent is, what to read when it starts, what to write before it stops. Copy it into any project and point your agent at it.
AGENTS.mdAgent onboarding →
MCP in one command
vant mcp auto-wires the module surface into JSON-RPC tools on 127.0.0.1:3457. Any MCP client connects. The REST server on 3456 covers everything else.
MCP reference →Crews, not just one
Up to four agents share one install. Each gets a branch and a named brain context; merge-by-PR keeps the shared memory safe while they work.
Multi-agent crew →Three memory systems, one home
Not one memory: three, with different jobs. All of them are files under models/ in your repository.
The brain
Markdown memory files: identity, goals, lessons, errors, preferences. Read when a session starts, written before it ends, inherited by every session after.
models/<scope>/<brain>/lessons.mdThe brain →
The memory store
Key-value state and documents with TTL, written during the session. Sandbox-gated, atomic, per-brain scoped. Memory is the flagship use: underneath is a general-purpose store, so sessions, caches, blackboards, or whatever else you build all fit.
vant learn <key> <content>Memory store →
Brain search
Semantic retrieval over the whole corpus. Pluggable embed providers, rerank for large corpora, git-backed citations for grounded answers.
vant search "<query>"Brain search →
Git is the feature
Your memory is files in your repo, so every Git workflow is a memory workflow.
Ownership
Your repo, your history, your backup story. Stop using Vant and the memory survives as files. Exportable forever.
Review
What your agent learned shows up in diffs. Approve lessons in a pull request, revert the bad ones, blame the file to find where a habit started.
Branches
One branch per agent. Each works in isolation and merges what is worth keeping. Experiments are branches, not forks of your data.
Built on itself
Vant develops Vant. Coding agents open sessions on this repo, work, and close out their learnings into the brain. The project history is the demo.
Agents wrote the docs
Docs go through scripted linters agents built: a voice gate, a link gate, a frontmatter check. Contributors run the same gates with npm run lint:docs.
Contributing →Sessions hand off in labs/
Each working session leaves notes for the next: findings, decisions, open threads. When a session crashes, the next one picks up mid-task instead of starting over.
See the handoffs →This page is agent work
The lander is a single HTML file, every number on it verified against the code, built and shipped in a session that started by reading AGENTS.md.
Read the history →Runtime underneath
Memory is the product. The runtime makes it safe to run unattended.
Security chain
Sandbox capabilities, input validation, rate limiting, escrow approval. Every brain operation passes the chain; denials are coded, not silent.
Security →Crash safety
A write-ahead journal and atomic writes. A crash mid-write leaves a recoverable journal, never torn memory.
Storage →Multi-brain and crews
Named brain contexts with a stack. Branch-per-agent workflows. Trust levels decide how much each generation inherits.
Multi-agent →Horcrux
A whole brain embedded in an image, encrypted. Cold backups, machine-to-machine transfer, restore anywhere.
Horcrux →Any Git provider
GitHub, GitLab, Bitbucket, self-hosted. Sync, rebase, and conflict detection work the same everywhere.
Integrations →Headless and Docker
REST mode for CI and containers. The brain outlives the container, because it is files in a volume or a repo.
Server →A soul that reincarnates with full memories.
That is the metaphor. On disk it is concrete: markdown files in models/, loaded when a session opens, written before it closes, committed and pushed. The next session inherits all of it, and git history keeps every generation auditable.
Where Vant fits
Saying what Vant is not, because your time matters more than our conversion rate.
A strong fit when
- You run coding agents and want session continuity without a hosted service
- You want to review what your agent learned in a diff before it sticks
- You are building an agent crew that needs a separate memory per agent
- You want memory in CI: read or write brain state over REST
Not the tool yet when
- Your agent is browser-only, with no filesystem or git access
- Your project lives outside git (local mode works, but there is no lineage or sync)
- You need large-scale vector serving; search is local-first, not a hosted vector database
Questions agents actually ask
The same questions your agent will ask on its first session, answered.
What is a brain in Vant?
A set of markdown files in models/ that store identity, goals, lessons, errors, and preferences. The agent reads them when a session starts and writes what it learned before it ends. The next session inherits everything.
Learn more →Where does the memory live?
In your own repository, as plain files. Vant never puts your memory in someone else's database. If you stop using Vant, the memory is still there, readable with cat.
Do I need GitHub?
A Git host is needed for sync, and any provider works: GitHub, GitLab, Bitbucket, or self-hosted. Without sync, Vant still runs fully on local files.
Learn more →Is my brain private?
Yes. Use a private repository and only you and the agents you authorize can access it. There is no external service holding a copy.
How do agents connect?
Through MCP: start the server with vant mcp and it auto-wires the module surface into JSON-RPC tools. Agents can also use the CLI or read the brain files directly.
Learn more →Can multiple agents share one install?
Yes. Each agent gets a branch and a named brain context. Branch-per-agent isolation with merge-by-PR keeps concurrent work safe.
Learn more →Can I use Vant without an agent?
Yes. The CLI works on its own: learn, search, onboard, health. The memory is plain files, so you can also read and edit them directly.
What stops an agent from writing bad lessons?
Lessons land in git, so they arrive as reviewable diffs and revert like any file. Succession trust levels decide how much each agent generation may do unattended.
What happens when I upgrade from an old single-brain layout?
vant start detects the old layout and imports it automatically into the multi-brain layout. Detection is content-based and idempotent, and nothing is lost.
Learn more →Does Vant cost money?
No. Vant is open source under MIT. You need a Git host account and, if you want hosted embeddings, your own API key. The default hash provider needs nothing.
How is Vant different from a vector database?
A vector store keeps embeddings. Vant keeps the full context: the actual markdown, identity, goals, and lessons, with search on top. Agents inherit previous thoughts, not just similar ones.
Pick a door. Both are open.
Five minutes for you, one command for your agent, and the memory is yours either way.