Managed memory and knowledge

Measured quality and latency

The August 27, 2026 authenticated API benchmark used three fresh isolated hosted accounts. Every account passed all eight lexical behavior cases, all six semantic Top-1 cases, and all three grounded-answer cases, including aliases, current and historical evolution, usage ranking, operational isolation, paraphrases, and unsupported-question abstention. The equivalent local typed-memory cases also passed in every fresh run.

Hosted recall is not as fast as the local vault path. Across the three hosted trials, the median trial p50 was about 0.53 seconds for lexical search, 4.89 seconds for semantic recall, and 5.93 seconds for grounded answers. The corresponding local lexical/API behavior trials had a median p50 of 7.85 milliseconds. A separate 48-distractor diagnostic kept every quality check passing and measured 0.43 seconds lexical p50, 1.67 seconds semantic p50, and 2.59 seconds answer p50, which also shows that hosted latency varies with request and service state.

These are measured product-path snapshots, not an availability or latency promise. The result supports quality parity on the published cases, not universal parity with every private vault. See Shared Brain Memory Benchmarks for corpus sizes, repetition counts, and limitations.

Keep the store clean

Cloud Superbrain rejects a second active memory on the same memoryKey, but two memories can still say the same thing under different keys. memory.consolidate finds them: it groups near-duplicates within a memory type by how much distinctive vocabulary they share, spots memories whose text says they correct an earlier note but were written without supersedes, and lists aged-out memories that nothing has ever retrieved.

It reports rather than merges. Merging two memories discards whichever wording loses, so each group comes back with the exact memory.evolve call that would consolidate it, for you to review. The one change it will make is archiving the aged-out candidates, and only when you pass applyArchives: true — archiving is reversible and applies only to context, event, observation, and action memories older than 120 days with no retrieval history.

memory.health now also reports duplicatePressure, so a scheduled check can watch the number without running a full consolidation pass.

const report = await hive.services.invokeOperation(
  "cloud-superbrain",
  "memory.consolidate",
  { applyArchives: false },
  { idempotencyKey: "aurora-consolidate-001" },
);

for (const group of report.result.duplicateGroups) {
  console.log(group.canonicalTitle, group.memberIds, group.evolveHint);
}

Learn from what your agents actually did

memory.minePatterns reads the account’s operational memories and proposes three things worth a person’s attention: a failure signature that keeps recurring across different tasks, a workflow repeated often enough to be worth turning into a skill, and an operation running on a cadence stable enough to be worth scheduling. Test and fixture traffic is excluded, and repeated retries of one task are not counted as a pattern — only the same thing happening across genuinely different tasks.

It proposes and never creates. Send a candidate to memory.create if you want to keep it.

Look inside a capsule before importing it

capsules.open returns a capsule’s manifest, an integrity verdict, and a summary of what is inside. capsules.search finds a memory within a capsule. capsules.preview reports exactly what an import would change: which memories are new, which the account already holds, and which would be refused for colliding with an active memoryKey. None of them write anything.

A capsule whose contents do not match its declared hash is still shown rather than hidden, with a warning — if a capsule is damaged, seeing what survived is more useful than seeing only an error.

Search by path

Memories carry a path, and most callers use it as a grouping. memory.browse summarizes those groups without returning any memory bodies: detail: "abstract" is about 100 tokens per group, overview about 2,000. Passing mode: "hierarchical" to memory.recall scores those groups before individual memories, so a memory’s neighbours come back with it and the reply names the paths it searched. Every memory stays eligible either way — hierarchy changes the order of results and never hides one.

Generations and historical recall

Each write publishes an immutable generation receipt. Use:

• generations.list to read retained generations and the visible replay boundary.
• generations.compare to find added, removed, and changed memory ids between two retained generations.
• memory.recall with generationId to replay a lexical question against a retained historical state.
• temporalMode: "historical" to include superseded and archived records, or temporalMode: "as-of" with asOf for a time cutoff.

Cloud Superbrain retains up to 256 generations per account. A request outside the reported replay boundary fails instead of silently substituting newer memory.

Knowledge nodes and backlinks

Memories with type knowledge, a knowledge tag, or a path under Synthesis/ become knowledge nodes. The registered operations are:

Use entities, aliases, and links consistently when another product needs dependable graph navigation.

Portable capsules

capsules.export returns a bounded, checksummed capsule for selected memory ids or the next page of the account. capsules.import verifies the schema and content hash before adding the records to the authenticated account. A capsule never grants access to its source account, and an import cannot overwrite another account’s memory.

Export no more than 100 memories per capsule part. Follow hasMore and nextCursor until the export is complete. Keep the capsule private when its memories are private; its checksum detects corruption but is not encryption.

Registered operations

Restrict a worker key to only the operations it needs. For example, an answer-only service can allow services.invoke.cloud-superbrain.memory.answer and set a separate request limit on that exact selector.