# recall vs Mastra

Mastra is a TypeScript framework for building agents; its observational memory has an observer model compress the conversation into dated observations and a reflector condense them. recall reads the chats Claude Code, Codex and Cursor already keep, indexes them with no model calls, and writes notes overnight with a model you choose.

Checked 17 Oct 2026 · recall 0.5.1 · [Mastra on GitHub](https://github.com/mastra-ai/mastra)

## At a glance

Mastra's memory keeps one long conversation inside a context window: as the history grows, a model rewrites it as a log of dated observations, and as that grows, another condenses the log. It is memory within an agent you build in TypeScript. recall's memory is between agents you did not build: it indexes every chat Claude Code, Codex and Cursor have saved and keeps a few notes a night that all three load at session start.

| | recall | Mastra |
| --- | --- | --- |
| Runs | On your machine | In your TypeScript app, self-hosted; Mastra's platform |
| Licence | MIT | Apache 2.0 core; `ee/` under an enterprise licence |
| Model calls to store a chat | **0** | **An observer call per 30k tokens**, reflector calls on top |
| A search takes | **11 ms** local, 47 with embeddings | No search: the compressed log is the context |
| Price | **Free** | Framework free; platform free tier, Team $250 a month |
| Chat text leaves your machine | **No**, with a local model | **Yes**: to the observer, reflector and agent models |
| Claude Code, Codex, Cursor | MCP, skill, session hook | None for memory: a docs MCP server only |

## Where both were measured

Mastra's LongMemEval headline is the highest published: 94.9% with gpt-5-mini answering over about 30,000 tokens of observations written by gemini-2.5-flash. With GPT-4o answering the same observations it scored 84.2%, which shows how much the answer model carries. recall 0.4.1 scores 88.4% with Claude Haiku 5.5 answering and judging, reading ~44k tokens of whole chats.

The two are not doing the same thing: Mastra hands the model a compressed transcript of the whole history, with no retrieval step to measure; recall searches, and that retrieval puts an answering session in the top five 98.7% of the time. On coding work, where Mastra has no figures, recall finds the past fix in its top five 80% of the time on SWE-ContextBench.

**Fig 1. recall 0.5.1 and Mastra** LongMemEval: answers correct and the context handed to the model, as each reports it.

| Measure | System | Figure | Note |
| --- | --- | --- | --- |
| Answers correct | Mastra · gpt-5-mini | 94.9% | its research post, observations by gemini-2.5-flash |
| Answers correct | recall 0.4.1 | 88.4% | Claude Haiku 5.5 answering and judging, reading the top 10 chats |
| Answers correct | Mastra · GPT-4o | 84.2% | the same observations, GPT-4o answering |
| Context a question | Mastra | ~30k | observations, its own figure |
| Context a question | recall 0.4.1 · top 10 | ~44k | ten whole chats, scoring 88.4% |
| Context a question | recall 0.4.1 · windows | ~17.5k | matched windows of the top 5, scoring 84.2% |

LongMemEval_S · Mastra's research post · recall 0.4.1, all 500 questions Mastra: gpt-5-mini or GPT-4o answering over observations written by gemini-2.5-flash. recall: Claude Haiku 5.5 answering and judging. Mastra's memory is a compressed transcript rather than a search, so there is no retrieval figure to set beside recall's.

## Cost

Mastra's memory costs model calls as the conversation grows: an observer call each time the history passes 30,000 tokens, reflector calls as observations pass 40,000, run asynchronously by default; its post reports prompt caching cutting that four to ten times. The framework is free; the platform's Starter tier is free and metered, Team is $250 a month.

recall spends no model calls to index or search, and its one model cost is the nightly notes, with a model you choose: nothing with a local one, covered by a subscription, batch prices on an API key.

| | recall | Mastra |
| --- | --- | --- |
| Model calls to store a chat | **0** | **An observer call per 30k tokens**, reflector calls on top |
| Price | **Free** | Framework free; platform free tier, Team $250 a month |
| To take in 300 sessions | **$0**, no model calls | Observer and reflector calls as history grows |
| Cost of memory | One nightly run, your model | Model calls per threshold crossed |

## Latency

Mastra's post calls observational memory low-latency and gives no numbers; with asynchronous buffering, observation runs beside the conversation and blocks only once the history reaches 1.2 times the threshold.

recall adds nothing to a turn: its search is a local index at 11 ms on ~2,800 chats, 47 ms with the embedding model, and the notes are written overnight.

| | recall | Mastra |
| --- | --- | --- |
| A search takes | **11 ms** local, 47 with embeddings | No search: the compressed log is the context |
| Wait at write time | **None**: reads saved chats | Asynchronous by default; blocks at 1.2× the threshold |

## Privacy

Mastra runs in your own application and stores observations as plain text in the database you chose; the text goes to the observer and reflector models you configured, Gemini Flash by preference, and to the agent's own model. Mastra publishes no data-residency statement for its platform.

recall runs on your machine, reads chats read-only, redacts secrets before indexing, and sends nothing anywhere except to the model you chose for the nightly notes. With a local model, nothing leaves.

| | recall | Mastra |
| --- | --- | --- |
| Runs | On your machine | In your TypeScript app, self-hosted; Mastra's platform |
| Licence | MIT | Apache 2.0 core; `ee/` under an enterprise licence |
| Chat text leaves your machine | **No**, with a local model | **Yes**: to the observer, reflector and agent models |
| Compliance | Nothing to certify: no service | No data-residency statement found |
| Telemetry | **None** | Platform observability, if you use it |

## How memory is built

Mastra keeps a transcript in compressed form: the observer turns messages into dated observations marked by priority, the reflector turns old observations into shorter ones, and the model reads all of it.

recall keeps every chat whole in a search index and a separate set of notes: preferences, project facts, decisions, lessons and open threads, each with a quote from its chat, in markdown under git, consolidated rule by rule once a night. Notes written by Claude Haiku 5.5 hold 91% of the conventions a mentor set on MemoryCode, and loaded at session start they lift an agent from 32% to 75% on long histories.

| | recall | Mastra |
| --- | --- | --- |
| Captured by | Reading the agents' own chat files | The agent's own message history |
| Memory is | Markdown notes in git, plus an index of every chat | Dated observations, as plain text in your database |
| Retrieval | Full-text index, five rankings fused; optional local embeddings | None; the model reads the observations |
| You can edit it | **Yes**, and the edit wins | In your database |

## Which to pick

**Pick Mastra if**

- You are building an agent in TypeScript and want its long conversations to keep fitting in the context window.
- You want the best published LongMemEval score and are happy to pay the observer and reflector calls.
- Your agent is yours; Claude Code, Codex and Cursor are not in the picture.

**Pick recall if**

- You use Claude Code, Codex or Cursor and want them to share a memory of your work with nothing to build.
- You want search over every past chat, not a compressed log of one, and no model calls to index it.
- You want memory you can read as markdown and revert with git.

## Questions

**Can Mastra's memory be used with Claude Code or Cursor?**

No. It attaches to an agent written with the Mastra framework; the only MCP server it ships serves its documentation. recall connects to Claude Code, Codex and Cursor through an MCP server, a skill and hooks, and reads their transcripts from disk.

**Why is Mastra's LongMemEval score higher?**

Partly the answer model: gpt-5-mini reading 30,000 tokens of observations scored 94.9%, and GPT-4o reading the same scored 84.2%. recall's 88.4% was measured with Claude Haiku 5.5 as both answer model and judge. recall's retrieval alone finds an answering session in the top five 98.7% of the time.

**Does Mastra search past conversations?**

Observational memory does not search; it keeps a compressed version of the thread in context. Mastra has separate semantic recall over a vector store for that. recall's search is the core: a full-text index over every chat, ranked five ways and fused, with an optional embedding model.

**Is Mastra open source?**

The core is Apache 2.0; the `ee/` directories are under the Mastra Enterprise Licence, free for development and licensed in production, and the hosted platform is paid above the Starter tier. recall is MIT with nothing hosted.

## Sources

- Mastra on GitHub: https://github.com/mastra-ai/mastra
- Mastra: observational memory: https://mastra.ai/docs/memory/observational-memory
- Mastra research: observational memory on LongMemEval: https://mastra.ai/research/observational-memory
- Mastra platform pricing: https://mastra.ai/blog/mastra-platform-pricing
- recall's chat benchmark runs, with the other systems' figures: https://github.com/alirng/recall/blob/main/docs/research/retrieval-benchmarks.md