Reflective Memory: The Interviewer

Every argument about agent memory eventually reduces to a question that comes before storage, retrieval, or governance: what put the memory there in the first place?

The usual answer is “the model called a save tool.” That makes remembering a decision something the model can skip — and it does, because it is busy doing the work. The fact evaporates, nothing errors, and you find out three sessions later.

Caura’s position is that capture is infrastructure’s job. But “infrastructure captures” hides a real choice, because there is more than one moment at which a memory can be written, and each moment sees something different. Caura names three modes and ships all three. This post is about the third — the one that recovers what the other two can never see.

Three ways memory gets written

Agentic. The model has memory as tools — recall and commit over MCP or REST — and calls them when it decides to. This is the mode every agent framework already has, and it is the right one when an agent needs to search memory in the middle of a task: “what did we decide about the auth flow?” is a question only the agent knows to ask. Its weakness is the write side. Committing is optional, and optional loses to the task.

Deterministic. Recall runs before the model and commit runs after, as code the context window never touches. On harnesses Caura runs inside — the OpenClaw plugin today — that is a beforeTurn hook that injects scoped facts and an afterTurn hook that extracts durable ones and writes them through governance. For agents you build yourself, Rail (in preview) brackets your own call the same way in about ten lines. The guarantee is invocation, not persistence: the model cannot skip the memory step, and if the store is unreachable the run continues. A fact stated this turn is searchable within seconds.

Reflective. No in-run memory call at all. After the fact, on a schedule, the Interviewer reads the agent’s own transcript and synthesizes typed memories — decisions, outcomes, tasks, preferences, facts — from work the agent never stopped to record. The agent pays nothing.

These are not alternatives. Agentic gives the agent a search box. Deterministic guarantees the stated facts land. Reflective recovers the reasoning. All three write through the same governance gate into one store, so a memory’s origin never changes its scope, provenance, or audit trail — only its type.

The gap the reflective mode closes

Deterministic capture is a strict improvement over agentic: the memory step cannot be skipped. But it can only capture what passes through the turn, and a running agent states very little outright.

It reads a codebase and picks an interface. It tries an approach, watches it fail, and quietly routes around it. It learns over forty turns that this user hates verbose diffs. None of that is ever said in a form an afterTurn extractor can see. The decision is real; the sentence describing it never existed.

That is the band of knowledge worth keeping, and it is the band the per-turn paths race straight past. The reflective mode exists to go back for it.

The Interviewer

The Interviewer is Caura’s reflective write path. Instead of asking the agent to journal — a chore that always loses to the task — it reads the session transcript that already exists and distills durable memories from it on a background pass.

Two mechanics keep it honest, and both are enforced in code, not prompt.

It never re-runs the agent. It summarizes the transcript that already exists, so every memory is grounded in what actually happened rather than a model’s reimagining of it. The agent is never re-invoked, never prompted, never slowed.

Invocation is scheduled, not discretionary. For fleets, a server-side sweep fires hourly, at the top of the hour, enumerates the orgs with interviewer.enabled, and queues one reflective request per due agent. For local agents, a cron entry you install does the same on the machine. The model gets no vote on whether reflection runs — the same determinism the per-turn path has, moved from per-turn to per-schedule.

And the output is a first-class citizen. Whatever the Interviewer recovers is written through the identical governance gate the deterministic path uses — auth, identity, tenant and fleet resolution, caller trust, quota, content policy, commit — under the same scopes and the same audit trail. A recovered memory is not a second-tier note. For the full argument behind this path, see Agents Don’t Journal.

What the Interviewer changed in production

Start with what agents write for themselves. Left to its own devices, an agent produces almost nothing worth keeping: 96% of what it logs is disposable episodic telemetry, recalled essentially never. The knowledge worth having is a thin band, and the agent races straight past it.

The Interviewer is where that band comes from. Of every decision-grade memory in the entire system, the share recovered from work no agent hand-wrote:

It is not filler — the oldest objection to auto-written memory ran backwards. As Interviewer memories aged, the fleet recalled them more. Reuse of every decision-grade type climbed past Caura’s quality baseline as the memories matured: outcomes from 6% to 20%, decisions from 3% to 11%, preferences from 1% to 11%. Memory that compounds instead of rotting.

The sharpest signal is that recovered memory travels. A memory earns its keep when a different agent recalls it — that is the moment one agent’s work becomes the fleet’s shared knowledge. When recalled, an Interviewer memory is 4× more likely to be answering an agent other than its author than a per-turn write is. In the clearest single case, one agent’s SmartPortfolio architecture decision — routing turn actions through runTurn and streaming SSE, never hand-written — was reconstructed from its transcript and then pulled 17 times by a different agent building against the same interface. One recovered edge accounted for a third of all organic cross-agent learning in the fleet.

Left to the agents, agent memory is 96% noise. The reflective mode is where the signal comes from — roughly half of every decision and two-thirds of every preference the fleet holds, captured with zero agent effort, and reused more the longer it lives.

Running the Interviewer

The Interviewer ships in the official Python client. There are two ways to run it: on a local agent’s machine (Claude Code, Cursor, the claude CLI), or as a fleet sweep for OpenClaw deployments. The steps below are validated against caura-client 1.0.0.

Local agents — three steps

One install per machine covers every agent on it. Requires Python 3.9+ and pulls a single dependency (httpx). It provides the caura-interviewer command.

1. Install and point it at your server.

pip install -U caura-client
export CAURA_BASE_URL=https://your-caura-server   # default: https://caura.ai
export CAURA_API_KEY=mc_xxxxxxxx                  # required
export CAURA_TENANT_ID=your-tenant                # required
export CAURA_INTERVIEWER_PROJECTS="my-app,acme-*" # allowlist — default-deny

Capture is default-deny. Your transcripts span every project on the machine, so the Interviewer reads nothing until you name projects in CAURA_INTERVIEWER_PROJECTS (comma-separated globs, or pass --all-projects to opt into everything). Only real prompts and replies are read, and credential-shaped strings are scrubbed locally before anything is sent.

2. Dry-run to confirm — this sends nothing. It prints the windows it would submit; if it lists project directories and exits, your allowlist isn’t matching yet.

# parse transcripts and print the windows it WOULD submit — sends nothing
caura-interviewer run --dry-run -v

3. Schedule it. One command writes the cron entry and a private (0600) copy of the settings for the background job. Pick the line for your harness:

# Claude Code / claude CLI (reads ~/.claude/projects/**/*.jsonl)
caura-interviewer install --interval 30m

# Cursor (reads ~/.cursor/**/agent-transcripts/**/*.jsonl)
caura-interviewer install --harness cursor --interval 30m

The cadence you pass to --interval (e.g. 30m, 1h) is what governs how often this agent is interviewed; re-run install with a new interval to change it. Capture begins after the job first runs, so give it one interval and a little activity before checking — nothing before install is back-filled.

Verify and manage

caura-interviewer status      # cursor vs local lines; pending=0 means drained
caura-interviewer uninstall   # remove the cron entry and its env file

Recovered memories appear in your dashboard typed as decision, outcome, task, fact, preference, or episode. If run lists project dirs and exits, the allowlist didn’t match; a 403 interviewer is not enabled for this tenant means the server-side flag is off — enable it and allow a couple of minutes.

Fleets — no per-node setup

For an OpenClaw fleet, you don’t schedule anything on the nodes. Set CAURA_INTERVIEWER=true on the plugin and enable the Interviewer for the org server-side. From then on, each node buffers its conversation events to a durable on-disk trail, the hourly server sweep queues a reflective request per due agent, and the node drains its buffer to POST /interview/submit — pruning only what the server confirms it committed, so nothing is lost across restarts. Same reflective pass as the local path, driven centrally.

Where reflective sits in your stack

The three modes compose. Which ones you run depends on how the agent is deployed, not on which is “best.”

One governed store, three ways in, and a door for every way an agent is deployed.

FAQ

What are Caura’s three memory modes?

Agentic, deterministic, and reflective. In agentic mode the model calls recall and commit as tools (MCP or REST) when it decides to. In deterministic mode infrastructure invokes recall before and commit after every turn, as code the model cannot skip — OpenClaw hooks today, Rail (preview) for agents you build. In reflective mode there is no in-run memory call at all: the Interviewer reads the agent’s transcript on a schedule and synthesizes typed memories from it. All three write through the same governance gate into one store.

What is the Caura Interviewer?

Caura’s reflective write path: a scheduled, read-only pass that reads an agent’s existing transcript on a cadence you set, distills the durable knowledge — decisions, outcomes, tasks, preferences, facts — and commits it as governed memory. It runs on the agent’s own machine for local harnesses (Claude Code, Cursor, the claude CLI) via caura-client, or as a server-scheduled fleet sweep for OpenClaw. It keeps no local state and captures nothing until you name the projects it may read.

Why isn’t deterministic capture enough?

It guarantees the memory step runs, but it can only capture what is stated during the turn. Most of what an agent knows, it does — it never narrates the decision, the failed approach, or the preference it inferred over forty turns. The Interviewer recovers that from the transcript after the fact. In the eToro fleet it accounts for roughly half of all decisions and two-thirds of all preferences the fleet holds.

Does the Interviewer slow the agent down or leak data?

No. It runs as a background pass that never re-invokes the agent, so the agent pays nothing. Capture is opt-in and default-deny: the Interviewer reads nothing until you allowlist projects, and credential-shaped strings are scrubbed locally before anything leaves the machine. Whatever it commits passes the same content policy — detect, flag, mask, drop — as every other write.

Getting started

The Interviewer is Apache 2.0 and ships in caura-client — self-hosted or managed, MCP-native. Agents Don’t Journal carries the full design argument and the collector internals, and the docs cover the tenant flag and the /interview/submit contract.

Related reading: Agents Don’t Journal · What Is Agent Fleet Memory? · Harness Engineering: Deterministic Memory

Production figures from a read-only analysis of the eToro deployment, 2026-08-25. Decision-grade = decision / preference / outcome / task / fact, excluding episodic telemetry; reuse = share of memories ever recalled; customer-identifying content generalized. Setup validated against caura-client 1.0.0.