Memory

The project remembers what the chat window forgets, and that single fact changes everything downstream. Memory is the load-bearing wall of the studio.

What the big chat apps call memory

Claude Projects, ChatGPT, and Gemini all ship memory now, and for a chat product it is genuinely useful. It is also rudimentary: an app-locked scratchpad where the model quietly decides what to keep about you. There is no separation between what you approved and what it inferred, no receipt for where a "fact" came from, no discipline about what fades, and no way to take any of it with you when you leave. A sticky note on one vendor's desk.

Auteur memory is a different organ, engineered like the rest of the studio. Nothing becomes memory by accident.

Adjudicated, not accumulated

Every candidate memory is judged before it is kept. The memory governor adjudicates what enters the record, with adversarial review from a different model family sitting on that judgment, so one model's confident hallucination cannot quietly become your project's truth. Memory is organized into governed classes, each with its own retention profile, and scoped along real axes: who, which workspace, which project, which lane, so the novel's canon never bleeds into the ad campaign's. Domain adapters give each lane its own memory sense: writing remembers like a writer's room, the Resolve lane like an assistant editor, the publishing lane like a campaign desk.

And forgetting is designed, not accidental. Decay is asymmetric: what stops mattering fades toward the archive instead of shouting forever, but fading is not deletion, an episode that fades was not wrong, it just stopped being load-bearing, and the archive keeps it findable. A protected tier sits above all of it: the memories that define the project cannot be touched by any tool at all.

Approved truth, kept apart

Canon lives separate from suggestions. What you approved is versioned, attributed, and retrievable; what a model merely proposed never quietly becomes fact. New sessions, and new models, start already knowing the project.

“Compare this draft against the project canon, flag contradictions, and prepare revisions without overwriting approved material.”

Model-agnostic. Platform-agnostic. Yours.

Memory belongs to the project, not to any model or app. It lives across every surface Auteur Intelligence™ touches, the desktop studio, the deck on your tablet, the harness you already use, the panel inside Resolve, so it persists, stays searchable, stays teachable, and stays relevant no matter which model is seated or which screen you are holding. Swap providers tomorrow; the project still knows everything it knew today. Memory travels with you wherever your projects take you.

Recall, the way people do it

The memory is designed the way human recall works: the facts you use stay top of mind, and what stops mattering fades toward long-term archive instead of shouting forever at equal volume. Retrieval surfaces what is relevant to the work in front of you, and the archive keeps the rest, versioned and findable, for the day you need it back.

Under the hood it is tiered like recall, too: a hot working set for the project in front of you, a warm index of summaries and canon, and a cold archive that keeps everything, with the archive tier mirrored into Notion databases, so your memory is always open to human review and walks out the door with you if you ever want it to. The log is continuous: ask for the conversation from a month ago, or what was decided yesterday around two in the afternoon, and it comes back with its receipt. And memory is organized the way your work is, broken down by project and by lane, so the novel's canon never bleeds into the ad campaign's.

“What did we decide about the ferry scene last month, and who proposed it? Show me the receipt.”

Where it lives is your call

Vector-indexed memory rides a proprietary architecture, but its address is yours to choose, and the postures differ honestly. The founder's own studio runs the whole memory organ locally: the vector index, the embedding model, and the archive all live on a GPU workstation, and recall never leaves the room. Cloud accounts run the same architecture hosted in your own tenant. Hybrid deployments keep the hot working set beside your media on your hardware while the hosted control plane coordinates. Either way it is versioned, backed up, and portable, never a hostage; the postures are laid out on the requirements page.

Retrievable, not just stored

Memory is working memory: retrieval feeds drafting, research, breakdowns, and builds with the project's own knowledge, so every room works from the same truth instead of a fresh guess.

Versioned and backed up

The record survives: memory is versioned, backed up, and auditable. Work compounds across months because nothing rests on a session staying open.

The standard memory is held to

Memory is easy to claim and hard to prove, so we hold it to marks a working studio can actually feel over months, not to benchmark scores. Each one below is written as a behavior you can check on your own project.

• Recall that carries over. Project canon, your preferences, settled decisions, recurring workflows, and explicit corrections are available when they are relevant, without you re-explaining them every session.
• Forgetting that is designed. Low-value and stale details lose retrieval priority over time, while canon, repeated preferences, and confirmed lessons stay durable. Fading means reduced influence before deletion, with a retention policy and an audit history behind it.
• Corrections that stick. A correction is stored with the behavior that failed, the context it failed in, the evidence, and the preferred replacement. On a similar task later the studio surfaces the warning or the preferred procedure, rather than simply recalling the thing it got wrong.

Learning you can audit

Improvement that cannot be inspected is just drift. Everything the studio learns from your work is recorded, gated, and reversible.

• Evaluation that is operational. Outputs, models, tasks, scores, human judgments, downstream outcomes, and the lessons that follow are connected to each other, so the dashboards read from real activity instead of from old or sparse statistics.
• A learning loop with brakes. Good and bad outcomes can change retrieval priority, model routing, prompts, policies, and reusable skills once they clear an evidence threshold. Nothing here retrains model weights. It is governed learning at the application level, and it rolls back.
• Graphs as working infrastructure. Characters, facts, sources, decisions, mistakes, tasks, and the relationships between them can be traversed for recall and for assembling context. That keeps canon consistent and cuts how much source text has to be sent to a model at all.
• Research that is graph backed. Open Notebook gives you source-grounded entity and relationship navigation and canon lookup, serving the same purpose as a research graph without copying anyone else's interface, and your existing source collections stay attached to the projects they belong to.

Boundaries, and proof

The parts that matter most are the ones about what memory will not do.

• History that stays intelligible. Existing memories, evaluation statistics, and large-build metrics are preserved and migrated rather than quietly reset, and they carry schema and version lineage, so performance before and after a change stays comparable.
• Accounts that stay separate. A paying customer cannot receive another account's memories, and the founder's own productions are private data, never fixtures or defaults inside the product.
• Sensitive memory by explicit act. Nothing sensitive is promoted into durable cross-session memory quietly. It takes a deliberate decision.
• Claims you can demand proof of. Behind a phrase like "learns your preferences" or "avoids repeated mistakes" sit canary results, replay tests, benchmark results, provenance traces, and rollback evidence.

What it looks like day to day

You notice it as an absence more than a feature: fewer repeated questions, fewer continuity errors, fewer corrections you have already given once, and behavior that stays consistent to this project rather than to models in general. When a memory or a lesson shapes an answer, you can see which one did.

The standard is not perfect human memory. It is useful long-term recall, controlled forgetting, traceable improvement, and no leakage between projects.