Skip to main content
The worst part of working with an agent is that it forgets. Close the chat and the next session starts cold — you re-explain your stack, your conventions, the quirk in that one file. V3Code is built so that never happens, and it does it without stuffing everything into the model’s context.

​
The idea: never forgets ≠ never forgets on the wire

“Never forgets” is a pull guarantee, not a push burden. Everything the agent ever saw — every prompt, reply, tool result, edit, and decision — is written to disk and instantly recallable. That does not mean it’s all shoved into the model every turn. The opposite: the agent holds only the live task in context and pulls the rest the instant it needs it. A chat assistant’s job is the conversation, so it clings to the transcript. An editor’s job is your code and your current intent — the conversation is scaffolding. So V3Code keeps the live wire small because nothing is lost and recall is excellent. This also dodges “context rot”: a stuffed context window makes a model perform worse, not better, so bounded-but-generous beats racing toward a million tokens.

​
The tiers

Native window

The recent raw turns the model holds itself. Cheapest, highest-fidelity memory there is — V3Code doesn’t interpose on it.

Session digest

A running fact-sheet of the middle turns that scrolled off. Once it exists it stays on the wire for the rest of the session — the agent’s own memory of what it already did.

Cross-session memory

Workspace facts, symbol notes, past sessions, other projects. Salience-ranked, scoped to what you’re touching, mostly pulled on demand.

Shadow floor

A raw, append-only record of every event. Never pruned. The break-glass guarantee behind “never forgets” — always recallable, never auto-injected.

​
What persists across sessions

  • Workspace memory — decisions, conventions, and notes tied to a project, surfaced when you’re in that project. Symbol notes live in .v3code/notes.json (see Context Bridge).
  • Global profile — style and preferences that travel with you across every project.
  • The full record — anything condensed or elided off the wire is still retrievable by the agent on demand; decay changes ordering, never what’s on disk.

​
How the agent keeps the wire lean

As a session grows, V3Code intervenes cheapest-first: hold the raw thread while it fits, elide old bulky tool outputs, then fold the conversation middle into the running digest only if still over budget — and it compacts rarely, near a large effective-context ceiling, not on every turn. Human-authored and test-verified facts are treated as evergreen.
Tell the agent to remember something directly — a convention, a gotcha, a decision and the reason behind it. The reason is the valuable part; save the why, not just the what, and it carries forward.

​
Memory that follows your code

V3Code’s memory isn’t a flat list — notes are pinned to your code’s structure and resurface by walking it. This is the “graph-anchored” part, and it’s what makes memory feel like the agent just knows your project.
  • The graph. The native symbol sidecar parses every file (tree-sitter) into a code graph — files → the symbols they define → the files that reference them. That’s the real dependency structure of your project.
  • Anchoring (write). When the agent saves a memory about code, it’s pinned to the relevant file/symbol nodes in that graph. Save it again and it’s re-confirmed — its confidence goes up.
  • The ripple (read). When a prompt is assembled, V3Code looks at the files you’re actively working in and recalls notes near them — rippling outward through the graph (the file’s symbols, the files that reference them, their neighbors). A note on the exact file arrives at full strength; one a couple of hops away still surfaces, just discounted.
The payoff: memory follows code structure, not keywords. Open a file and the agent automatically remembers the decisions, gotchas, and history attached to that neighborhood of the codebase — including notes on files it hasn’t even opened — without running a single search. And it gets richer on its own: as the agent explores code, what it learns is recorded automatically, so the map of your project deepens just from working in it.
Honest limits: this pulls from your few most-active files (a handful of notes each) per prompt; it uses the symbol sidecar (without it, memory gracefully falls back to the editor’s own store); and every workspace starts empty — nothing is pre-populated.
Working in a blank/greenfield folder? V3Code deliberately suppresses cross-project memory there, so the agent grounds in the empty project in front of it instead of hallucinating off unrelated history. Everything stays recallable on demand.