Remember

Remember is the fourth move of the Trust Loop, and the one that makes the first three compound. Understand captured the reasoning, Prevent recorded the verdicts, and Fix attached the corrections. Remember persists all of it as enterprise memory, so the next run does not start from zero. Without this step, governance is a logbook. With it, governance is something the system learns from.

Decisions accumulate on a graph

Every governed decision, with its claims, evidence, policy verdicts, and any human corrections, is written to a shared reasoning and memory graph. It is not a flat log of past runs. It is queryable context: a later run can read the prior decision that matches its situation and start ahead of where the earlier one did.

Carrying the refund agent forward, the assumption a reviewer corrected in Fix, that the customer tier was inferred rather than confirmed, is now memory. The next run on that customer reads it before it reasons.

The second run reads the correction and branches on the confirmed priority tier straight away. The weak assumption never recurs, not because the prompt changed, but because the decision that fixed it is part of the record the agent now draws on. A memory read is a step like any other. It shows up on the trace with its own latency and cost, so you can always see what the agent recalled and where it came from.

What gets remembered

Memory is not the raw transcript. It is the governed, structured outcome of each run:

• Decisions. The claims an agent acted on and the evidence behind them.
• Verdicts. Which policies fired and how, so a precedent carries its governance with it.
• Corrections. Every human fix and escalation, attributed, so judgment made once is available everywhere.
• Outcomes. What actually happened after the decision, which is what lets the graph distinguish a good call from a lucky one.

Read the learnings over the API

Accumulated memory is readable at the studio level. One call summarizes the last N runs into the patterns a single run cannot show: which optimizations keep firing, which policy gates keep failing, and what each model costs. Setup (gateway URL, studio key, studio id) is the same as in Understand.

curl -s -H "X-API-KEY: $EXPLAINABILITY_API_KEY" \
  "$EXPLAINABILITY_GATEWAY_URL/v1/studios/$STUDIO_ID/insights?window=20"

{
  "studio_id": "<your-studio-id>",
  "window": 20,
  "run_count": 20,
  "recurring_categories": [
    {
      "category": "prompt_cache_eligibility",
      "kind": "cost",
      "run_hits": 7,
      "of_runs": 20,
      "opt_count": 7,
      "avg_confidence": 0.92,
      "avg_impact": 0.79
    }
  ],
  "common_policy_failures": [
    { "gate": "Base MDM on three defined elements", "fail_count": 7, "pass_count": 0, "fail_rate": 1.0 }
  ],
  "cost_by_model": [
    { "model": "claude-haiku-4-5-20251001", "total_cost_usd": 0.0587, "runs": 3, "avg_cost_usd": 0.0196 }
  ],
  "fleet_summary": {
    "run_count": 20,
    "total_spend_usd": 0.3052,
    "median_cost_usd": 0.0039,
    "gate_pass_rate": 0.649
  }
}

Request parameters:

Response fields:

A recurring category is a pattern, not an incident: the same optimization firing on seven of the last twenty runs is the signal to fix the agent, not the run. Pair it with the per-run reads on Understand and the feedback write path and a coding agent can run the whole improvement loop unattended.

Logging becomes learning

When decisions are remembered, three things change:

• Corrections do not have to be repeated. A fix made once is reused automatically, so the same mistake is caught earlier, or avoided entirely, on every later run.
• Precedent accrues. Similar decisions resolve consistently because the agent can see how the matching case was handled before.
• Each run starts ahead. The system gets more reliable the more it is used, rather than relearning the same lessons.

Where memory lands: Collective Intelligence

Remember closes the Trust Loop for a single agent. The same graph spans every agent and every team, which is where it stops being one agent getting better and becomes an organization getting better. Each team gets the benefit of every governed decision that came before it. That compounding layer is Collective Intelligence: every capability writes into it, every capability is powered by it, and it is the intelligence behind the Studios your customers ship.

Next steps