Agent memory

Memory that survives the session.

A conversation ends. The work continues. Minds gives your agent six kinds of memory for the experiences, sources, and routines it needs next—all in your dedicated Mind, powered by Akasha.

Start free Explore the docs

Memory

Every conversation.
A little more context.

The details that make an answer yours deserve somewhere to stay.

Customer conversationYesterday

I do my best work somewhere quiet.

I’ll keep that in mind.

MINDS / MEMORYIllustrated example

A detail worth keeping.

A preference becomes a memory, together with the conversation it came from.

Choose a step to explore

The six types

Remember more than the conversation.

A customer preference, a troubleshooting routine, and an API key need different treatment. Each memory type gives your agent a useful way to store and retrieve a different part of its work.

Episodic · What happened

Keep a history of conversations, decisions, and outcomes. Recall the last interaction with its time and source attached.

Procedural · How to do it

Save a useful routine as a sequence of steps. Your agent can return to the same playbook when the task comes around again.

Resource · The source material

Keep documents and files close to the work. Find them through searchable descriptions and metadata, then return to the original material.

Vault · Sensitive information

Store credentials and other sensitive values in an encrypted vault, with access controls suited to their sensitivity.

Working · The task at hand

Keep the current goal and useful context in focus. Temporary information fades as the work moves on.

Associative · A familiar pattern

Use an incomplete clue to recall a stored pattern. Useful when a signal resembles something your agent has encountered before.

Build with memory

Give the next interaction a head start.

Start with one useful detail. Through the HTTP tool adapter, your application can save a preference and recall it later. Separate memory interfaces cover experiences, procedures, resources, and protected values.

Remember a preference through the HTTP tool adaptertypescript

// Run server-side with credentials scoped to this Mind.
const endpoint = process.env.AKASHA_URL;
const capability = process.env.AKASHA_CAPABILITY;
if (!endpoint || !capability) throw new Error("Configure your Mind connection");

async function request(method: string, path: string, body?: unknown) {
  const headers: Record<string, string> = {
    "Content-Type": "application/json",
    "x-akasha-capability": capability!,
  };
  if (process.env.AKASHA_TOKEN) {
    headers.Authorization = "Bearer " + process.env.AKASHA_TOKEN;
  }
  const response = await fetch(new URL(path, endpoint), {
    method, headers,
    body: body === undefined ? undefined : JSON.stringify(body),
  });
  if (!response.ok) throw new Error("Mind request failed: " + response.status);
  return response.json();
}

await request("POST", "/v1/mcp/tools/call", {
  name: "remember",
  arguments: {
    content: "The team prefers a written summary before each review.",
    memory_type: "episodic",
    tags: ["review-preference"],
  },
});
const recalled = await request("POST", "/v1/mcp/tools/call", {
  name: "recall",
  arguments: { query: "review preference", limit: 5 },
});
// Inspect recalled.is_error before using recalled.result.memories.

Auditable forgetting

Keep the context. Keep control.

Useful memory needs a source and a lifecycle. Akasha provides source tracking, configurable checks for incoming knowledge, and auditable forgetting that records the reason for a removal.

Memory architecture

Memory types: 6 (episodic, procedural, resource, vault, working, associative)
Capacity model: Bounded slots (working)
Decay functions: linear · exponential · power-law · ACT-R
Source attribution: observed · inferred · imagined · reported · reconstructed
Event context: timestamp · source · structured metadata
Concurrent access: MVCC — versioned reads and writes
Engine: Akasha

Forgetting & lineage

Audit chain: BLAKE3 record hashing
Vault encryption: AES-256-GCM
Vault key derivation: HKDF-SHA256
Forgetting: recorded reasons and operation history
Lineage: source and derivation tracking
Quarantine: verification gates before promotion
Deletion evidence: audit records for covered deletion operations

Keep exploring

Reasoning

Use remembered context to work through the next decision.

Knowledge Graph

Connect people, facts, and events without losing their history.

Cognitive Cycle

Bring memory into the cycle of observing, deciding, and acting.

Build on what your agent already knows.

Start with the conversations, documents, and routines that matter to your work. Keep them in your own dedicated Mind.

Start free View pricing