Memory

What it remembers

Decisions, lessons, and plans are captured as you work and come back when they matter.

“remember that we use Postgres, not MySQL”

Saved as a decision, and applied on later turns.

“what did we decide about retries?”

The decision, when it was made, and what it replaced.

“lesson: never use `any` in this codebase”

Saved with a trigger so matching future work can warn the assistant.

“what were we working on last week?”

The sessions, what changed, and where you stopped.

What is automatic

Approved plans and explicit saves are durable. ContextCode also records local session history for resume, and, while signed in, sends completed exchanges and session snapshots to shared history on a best-effort basis.

Relevant saved context can return without you naming each record. That is different from automatically saving every statement: retrieval can be proactive while important durable knowledge still requires an explicit, correctly shaped record.

The assistant may recognize a stated decision or correction and capture it, but do not make an important rule depend on inference. Say "remember that…", "record this decision", or "lesson: …" when you want a guaranteed durable record with the right behavior.

What it keeps

Kind	What it is
Decisions	"We chose X over Y, because Z"
Lessons	"This went wrong once — don't do it again"
Preferences	How you like things done
Plans and tasks	What you set out to do, and what's left
Local session history	ContextCode turns on this machine, for resume and export
Shared transcripts	Completed exchanges captured by ContextCode or opted-in editor connections
Documents	Runbooks, specs, postmortems you wrote down

What gets remembered covers the whole model.

Browsing it

Code

/decisions        decisions on this project
/lessons          lessons, and what triggers them
/preferences      saved preferences
/plans            active plans
/recall <query>   search all of it

It's the same memory everywhere

This isn't ContextCode's memory — it's your project's. Something decided in ContextCode this morning is available to Cursor this afternoon, and to a teammate with access to the same workspace. The local resumable conversation stays on the machine where it ran; the durable decision and shared history are what cross tools. See the Editors track.

When it's wrong

Say so. "That's not right, we moved off Redis in March" supersedes the old decision rather than adding a contradicting one. The history stays — you can see what changed and when — but the current answer is the current one.

If it doesn't work

It doesn't remember something we discussed. Discussion isn't a decision. If it matters, say "remember that…" and it's saved explicitly.

It's applying an out-of-date decision. Correct it once. The old one is marked superseded.

A brand-new project knows nothing. Correct — memory starts empty and fills as you work. AGENTS.md is the fast way to seed the conventions that matter from day one.