---
title: "Memory API for AI agents"
description: "Ingest timestamped text and query its current state, with source evidence."
canonical: https://past.dev
last-updated: 2026-08-26
---
# Memory API for AI agents

> Send timestamped emails, transcripts, tickets, and notes, then ask across all of it. past.dev returns the fact that currently holds, with dated evidence, for a fraction of what resending your history to a model costs.

- 93% retrieval sufficiency on BEAM 100k
- Unlimited context window. Ask across everything you have ingested.
- 20x cheaper per question than sending 1M tokens of history

Source: https://past.dev/

## The API

- `POST /api/v1/ingest`: raw text plus a timestamp, backdatable so history lands on its real dates
- `GET /api/v1/ingest/{id}`: poll until `settled` is true before reading
- `DELETE /api/v1/ingest/{id}`: delete a source and facts supported only by that source
- `POST /api/v1/recall`: return ranked evidence for your application or model
- `POST /api/v1/answer`: return an answer, evidence, cost, and `abstained` status

```bash
curl -X POST https://api.past.dev/api/v1/ingest \
  -H "Authorization: Bearer $PAST_API_KEY" \
  -d '{ "content": "Nadia confirmed the pilot ships March 14.
                    Budget is 32k.",
        "timestamp": "2026-02-03T09:00:00Z",
        "group": "acme-pilot" }'

curl -X POST https://api.past.dev/api/v1/ingest \
  -H "Authorization: Bearer $PAST_API_KEY" \
  -d '{ "content": "Budget for the Acme pilot moved to 40k.",
        "timestamp": "2026-07-28T16:00:00Z",
        "group": "acme-pilot" }'
```

```bash
curl -X POST https://api.past.dev/api/v1/answer \
  -H "Authorization: Bearer $PAST_API_KEY" \
  -d '{ "query": "what is the Acme pilot budget?" }'
```

```json
{
  "answer": "40k. It moved from 32k on July 28.",
  "evidence": [ { "marker": 1,
      "label": "Email from Nadia, 2026-07-28" } ],
  "abstained": false,
  "usage": { "answerCostUsd": 0.000431,
             "recallCostUsd": 0.000214 }
}
```

## Two calls to your first answer

1. **Get a key**: Request access and tell us what you are building. Keys are issued by hand during early access.
2. **Ingest data**: POST text and its original timestamp to `/api/v1/ingest`. Backfilled data keeps its original date.
3. **Query the data**: POST a question to `/api/v1/answer`. The response includes the answer, evidence, cost, and an `abstained` flag.

## Built in, not bolted on

- **Backdatable ingestion**: Backfill existing data using its original timestamps.
- **Entity resolution**: Resolve the same person across email, transcripts, and Slack.
- **Evidence on every answer**: Answers include dated source evidence.
- **Cost on every response**: Responses report cost in dollars.
- **Abstention over guessing**: If evidence is insufficient, `/answer` returns `abstained: true`.
- **MCP, both ways**: Reach your own account from an MCP client, and build your users' MCP server on `/recall` and `/answer`.

MCP: Point your own agent here to work on your account. To give your users memory inside your product, build your MCP server on `/recall` and `/answer`: you keep your user directory, past.dev keeps the memory. Endpoint: https://api.past.dev/mcp

## One engine, two homes

| Component | Managed | Self-hosted |
| --- | --- | --- |
| API and console | api.past.dev | the published past:0.1.1 image |
| Graph and storage | Postgres + pgvector, ours | Postgres + pgvector, yours |
| Background jobs | Temporal, ours | Temporal, optional profile |
| Sign-in | WorkOS AuthKit | Local accounts, your database |

No lock-in. Same images either home, ingestion replays anywhere, and self-hosted the memory is your Postgres. The surfaces are identical either way: POST /api/v1/*, api.past.dev/mcp, past.dev/mcp, openapi.json. Self-hosted is docker compose up -d. Pinned public images, no third-party services. Docs: https://past.dev/docs/memory-api/self-hosting

## Why it is different

### Current-state tracking

past.dev tracks current and previous values, including their dates and sources.

### Entity resolution

Who is who gets resolved when data lands, and stays resolved as the graph grows. Not reconstructed in a prompt at question time.

### Published benchmarks

The harness runs LoCoMo on corrected keys, LongMemEval and BEAM, with baselines and judges in the same table.

## Choose how to start

### Build on your own

Free to try on your own data. No card, no commitment.

- 10,000 ingest requests and 1,000 questions a month
- 5,000 resolved entities, one project, unlimited end users
- Pay as you go when you outgrow it: prepaid credits, no ceilings

### Enterprise and design partners

Same engine, volume rates, plus the terms platform teams need.

- Volume pricing on an annual commitment
- Dedicated or in-region deployment, SLA, DPA, SSO
- A direct line to the team

## Frequently asked questions

### What do I send?

Text plus a timestamp: emails, meeting transcripts, Slack messages, support threads, CRM notes, documents. There is no schema to define, no embedding model to choose and no chunking pipeline to build.

### What comes back?

`/recall` returns ranked, sourced evidence for your own model to reason over. `/answer` returns a grounded answer, the evidence it used, and its cost in dollars, or `abstained: true` instead of a guess.

### How is this different from search or RAG?

Search returns what resembles the question. past.dev returns which fact currently holds, with prior values dated and sourced. Identity, time, state and evidence are handled before the evidence reaches your model, rather than left to it.

### Whose memory is it?

The project's, not one user's. One connected graph per project, so the same person seen in email, a transcript and Slack is one node rather than three. During early access everything ingested through the API is visible to everything reading that project: per-reader audience scoping is on the roadmap, not shipped. Keep data with different authorization boundaries in separate projects.

### How much does it cost?

Every `/recall` and `/answer` response reports `usage.recallCostUsd` and `usage.answerCostUsd`. What you see on the invoice is what the API told you at request time.

### How do I get access?

The Memory API is in early access with a small group of design partners. Request access and tell us what you are building.