rekall

we will remember it for you, wholesale

Memory for the agentic era

Persistent memory that travels across every AI agent, team, tool and system with infinite context and personalisation. Own your conversations, memory, artifacts and more in Claude, ChatGPT, Cursor, and every AI tool you use everywhere, all at once.

Get Started Free View Docs

The problem

AI tools are powerful — but they have no memory.

restart_alt

Every session starts from zero

AI assistants have no memory between conversations. Every new chat is a blank slate — your history, gone.

view_column

Context trapped in silos

ChatGPT doesn't know what you told Claude. Cursor doesn't know your preferences. Your knowledge is scattered.

repeat

You repeat yourself constantly

Same instructions, same preferences, same context — every single time. It's exhausting.

How Rekall works

Three steps. Infinite context.

Store

Memories are captured automatically or via API from any connected tool. No manual effort required.

Understand

Rekall categorizes into 7 memory types, builds knowledge graphs, and connects the dots across your tools.

Recall

Any connected tool can retrieve relevant context instantly. Semantic search finds what matters.

What can you build?

From one developer's cross-tool memory to fleets of production agents — all of it backed by a real knowledge graph, not just a vector store.

smart_toy

A multi-agent coding fleet with shared memory

One agent learns it. Every agent knows it.

account_tree

The “why” archive — decision memory

“Why is auth done this weird way?” finally has an answer.

auto_awesome

Skill codification — workflows that teach themselves

Work out a tricky procedure once. Rekall turns it into a skill your whole team runs.

play_circle

Durable agent runs — checkpoint, resume, audit

A crashed agent resumes from its last checkpoint, not from scratch.

restore

Immortal agents

The agent is the memory, not the process. Kill it, redeploy it, resurrect it anywhere.

grid_view

See all 31 use cases

Personal, team, production agents — and husk agents

Explorearrow_forward

Seven types of memory, working together

A multi-layer memory architecture inspired by human cognition. Each layer serves a unique purpose.

movie

Episodic

Capture conversations, interactions, and events as they happen

"Remember that meeting where we discussed the new feature?"

psychology

Semantic

Store facts, concepts, and knowledge independent of when you learned them

"Python is my preferred backend language"

settings

Procedural

Remember how to perform tasks — workflows, deployments, recipes

"Here's how I deploy to production..."

palette

Preferences

Your style, choices, and personal settings across all tools

"I prefer concise responses with code examples"

schedule

Short-Term

Working memory for active context and in-progress conversations

"What we discussed 3 messages ago"

inventory_2

Long-Term

Consolidated knowledge and experiences stored permanently

"That Python technique from last month"

play_circle

Execution

Persist agent state, checkpoints, and resume interrupted workflows

"Resume the migration from step 4 where it paused"

One memory layer, all three lanes

Agent memory has split into three lanes — and most tools pick one.

Lane 01

manage_search

Fact stores

Extract facts, search facts. Semantic memory for what your team and agents know.

"What database does the billing service use?"

Lane 02

timeline

Temporal knowledge graphs

Facts with dates and invalidation, so point-in-time queries answer what was true — and when it changed.

"Which region were we deployed in last March?"

Lane 03

gavel

Governance layers

Policy checks, approvals, and audit trails for what agents are allowed to do — and what they did.

"Who approved that schema migration?"

Rekall ships all three in one memory layer

Built for teams and their agents — facts, time, and governance in the same recall.

Fact storescheckTemporal knowledge graphscheckGovernance layerscheck

Measured, not asserted

86.6%

recall@10 on LoCoMo (accurate tier)

100%

hit-rate@10 on LongMemEval-S — all 500 questions

+14.1pp

on temporal questions, from the bi-temporal graph’s point-in-time queries

100%

on our internal decision-context eval (n=26, Sonnet 5) — “why did we decide X, and is it still current?” answered from structured bi-temporal records

<1s

p95 recall latency — no LLM in the default path

“I don’t know”

refusal discipline measured and published — instead of hallucinating

Measured, reproducible, pinned judges — including our negative results. See how we measurearrow_forward

Built for developers

SDKs, APIs, and MCP — integrate memory in minutes.

agent.ts

import Rekall from '@rekall/agent-sdk';
const rekall = new Rekall({ apiKey: 'rk_...' });

// Store a memory
await rekall.learn(
  "User prefers TypeScript with strict mode"
);

// Recall relevant context
const context = await rekall.recall(
  "What languages does this user prefer?"
);

code

TypeScript, Python, Go SDKs

First-class support for the languages you use. Type-safe, well-documented.

smart_toy

MCP server for Claude Desktop & Cursor

Drop-in MCP integration. Your AI tools gain persistent memory with zero code.

api

REST API with webhooks

Full HTTP API for any platform. Webhooks for real-time memory events.

public

Browser extension for Chrome / Brave

Capture context from web pages and inject memories into any browser-based AI.

Read the developer docsarrow_forward

downloadGive this to your coding agent — agent-quickstart.md

Works everywhere you need it

40+ MCP tools. 3 SDKs. REST API. Browser extension.

smart_toy

Claude Desktop

MCP server for persistent memory in Claude

terminal

Claude Code

Memory-aware coding agent sessions

code

Cursor

Project context that persists across sessions

edit_note

VS Code

Extension for inline memory access

chat

ChatGPT

Cross-platform memory via browser extension

public

Chrome / Brave

Capture and recall from any web page

Memory for every scope

Agent, personal, or team — you control where memories live.

smart_toy

Agent Memory

Give your agents persistent identity, memory isolation, and multi-agent coordination. Agents remember past runs and checkpoint execution state.

check_circleAgent husks (persistent identity)
check_circleExecution state & checkpoints
check_circleMulti-agent constellations
check_circleHuman-in-the-loop approvals

face

Personal

Your coding style, language preferences, project context — encrypted and portable across every tool.

check_circleFully private and encrypted
check_circleTravels with you across all agents
check_circleYour data, your control

hive

Hive Mind

Team documentation, shared workflows, institutional knowledge that never walks out the door.

check_circleTeam-wide knowledge sharing
check_circleCollective learning and growth
check_circleUnified organizational memory

Simple, transparent pricing

Free to start. Scale as you grow.

Free

$0forever

For developers experimenting with memory-powered agents.

check_circle1,000 memories/month
check_circle100 API calls/min
check_circleCommunity support

Pro

$29/month

For developers building production applications.

check_circle50,000 memories/month
check_circle1,000 API calls/min
check_circleEmail support (48h)

Team

$99/month

For teams building collaborative multi-agent systems.

check_circle500,000 memories/month
check_circle5,000 API calls/min
check_circlePriority support (24h)

Enterprise

Custom

Advanced security, compliance, and scale.

check_circleUnlimited memories
check_circleCustom rate limits
check_circleDedicated support + Slack

View full comparisonarrow_forward

Stop teaching your AI the same things twice

Free for personal use. No credit card required.

Get Started Free Talk to Sales