# past.dev > The past.dev API gives your AI agents long-term memory: what's true now, what changed and when, who can see it, and where it came from. Also written: Past AI, pastdev, past dev. Handles and package names: pastdotdev, and past-dev for the CLI. All refer to this company and product. Backed by General Catalyst, Varsity, Connect Ventures and Hummingbird. Sign-up is self-serve: anyone can create an account, and it starts with 50,000 credits, 200,000 with a work email. No card required, and nobody approves the account. The reference documents available features. ## When to use past.dev Use past.dev when software must retrieve current or historical facts from unstructured records: - An agent that must know the current state of an account, a project or a person from emails, meeting transcripts, tickets or CRM notes, with the evidence behind each claim. - Long-running work where facts change over time: past.dev returns the current fact and includes dated sources for current and prior values. - Applications that need ranked memory documents with dates and source excerpts, while keeping answer generation under their own control. past.dev queries only the history you ingest. It does not search the web. Send timestamped text, wait until the send's status is completed, then recall source-backed memory as JSON. ## How to call it - REST under https://api.past.dev/api/v1, bearer auth: a project key (past_sk_) for memory, identities and audiences, the organization's management key (past_mk_) for projects and project keys. Machine-readable surface description: [OpenAPI](https://past.dev/openapi.json). - MCP (Streamable HTTP) at https://app.past.dev/mcp, manifest at [/.well-known/mcp.json](https://past.dev/.well-known/mcp.json), OAuth sign-in, no key to paste. - The console is at https://app.past.dev: project keys on the API keys screen (one per project, the project chosen in the header), the management key under Settings, Organization, Management key, audiences and identities on the Audiences screen, every call on the Requests screen. - Sign-up is self-serve at https://sso.past.dev/sign-up. After sign-up, create project keys in the console or with the management API. - No account yet: a coding agent can follow [/SKILL.md](https://past.dev/SKILL.md). `npx -y past-dev@latest init` creates an unclaimed project and writes its key to a file; the person claims it by signing in. - Docs over MCP, no auth: https://past.dev/mcp (server card at [/.well-known/mcp/server-card.json](https://past.dev/.well-known/mcp/server-card.json)). NLWeb queries: POST https://past.dev/ask. - How agents authenticate: [/auth.md](https://past.dev/auth.md). Machine-readable pricing: [/pricing.md](https://past.dev/pricing.md). - API discovery per RFC 9727: [/.well-known/api-catalog](https://past.dev/.well-known/api-catalog); agentic resources at [/.well-known/ai-catalog.json](https://past.dev/.well-known/ai-catalog.json). - Every page answers `Accept: text/markdown`, a `.md` suffix (/index.md for the root), and `?mode=agent`. ## Ingest, wait for completion, then recall Write any text with its original timestamp, then query it. Poll `GET /api/v1/ingest/{ingestionId}` until `status` is `completed` before expecting recall to reflect that send. ```bash curl -X POST https://api.past.dev/api/v1/ingest \ -H "Authorization: Bearer $PAST_API_KEY" -H "Content-Type: application/json" \ -d '{"content": "Renewal moved to March 12, 2026 per Dana.", "timestamp": "2026-01-08T09:14:00Z", "identity": "demo-user"}' curl -X POST https://api.past.dev/api/v1/recall \ -H "Authorization: Bearer $PAST_API_KEY" -H "Content-Type: application/json" \ -d '{"query": "When is the renewal?", "identity": "demo-user"}' ``` Recall returns one JSON result per document, with rank, dates, artifact context and verbatim source excerpts. The authenticated MCP server also recalls and ingests: `recall_memory` and `ingest_memory` act on a project's memory as these REST calls do, for a signed-in member, in the projects that member reaches. The connection configuration is: ```json { "mcpServers": { "pastdev": { "type": "http", "url": "https://app.past.dev/mcp" } } } ``` ## How to model your data - To set up an integration in order, with every call and the response that gates the next step, read Setup: https://past.dev/docs/memory-api/setup/llms.txt - One data point is one thing that happened: one conversation for one day, one email, one record, one document, timed at its first message. Keep a conversation part under 16,000 characters and a document part under 32,000. Give every data point a stable `id`; the same id with new content replaces it. - `audience` on a data point decides which identities can read it. An audience is a fixed list of identity ids or a rule over their traits, created in the console or with `PUT /api/v1/audiences/{slug}`. A data point sent without one is visible to every identity of the project, and a re-send without one becomes project-visible. - `identity` on a recall is the reader. The read returns project-visible memory plus every audience that identity reaches. `identity` on a data point is the optional author, never the scope. - `metadata` is stored with the data point and never filters a recall. To read one scope only, recall as an identity whose only audience is that scope. Guides: [Setup](https://past.dev/docs/memory-api/setup/llms.txt), [Concepts](https://past.dev/docs/memory-api/concepts/llms.txt), [Access control](https://past.dev/docs/memory-api/access-control/llms.txt), [Sending data](https://past.dev/docs/memory-api/sending-data/llms.txt). ## The corpus, in fetchable sections - [The core site in one file](https://past.dev/llms-full.txt): key pages, pillar guides, recent posts, full docs. - [Every landing guide in full](https://past.dev/guides/llms-full.txt) - [The glossary, every term in full](https://past.dev/glossary/llms-full.txt) - [Every blog post in full](https://past.dev/blog/llms-full.txt) - [All docs as Markdown](https://past.dev/docs/llms-full.txt) ## Pages - [Long-term memory API for AI agents](https://past.dev): Improve your agent's long-term memory. The memory API, #1 on BEAM, the largest public memory benchmark. - [Pricing](https://past.dev/pricing): Three plans metered in credits, where one credit buys 350 bytes of ingested payload. Storage and seats are not metered. - [Enterprise](https://past.dev/enterprise): Run past.dev as a managed service, or in your own cloud account. The same engine and the same API in every case. - [Benchmarks](https://past.dev/benchmarks): BEAM accuracy at 100K, 500K, 1M and 10M tokens against published results from memory providers, LoCoMo on corrected keys, and the evaluation method. - [DolphinBench leaderboard: agent memory scored on actions](https://past.dev/benchmarks/dolphinbench): Every published DolphinBench result in one place, from Mem0's official runs to past.dev's self-run 490 of 600, each figure linked to its source. - [BEAM leaderboard: long-term memory benchmark results](https://past.dev/benchmarks/beam): Published results from memory providers on BEAM, the ICLR 2026 long-term memory benchmark, at 100K, 500K, 1M and 10M tokens, each figure linked to its source. - [About past.dev](https://past.dev/about): The company, founders, product principles, benchmark standards, and investors behind past.dev. - [Startup program](https://past.dev/startup-program): Six months of the Flex plan free for early-stage startups, with additional credits sized to what you are building. Apply from the page. - [past.dev community](https://past.dev/community): Join the past.dev community Slack to ask questions about the Memory API and share what you build with other developers. - [Contact past.dev](https://past.dev/contact): Email contact@past.dev to reach the past.dev team, support@past.dev for a product question, or book a call about integrations, Enterprise and billing. Sign-up itself is self-serve and needs no call. - [Security](https://past.dev/security): SOC 2 Type II, ISO 27001, ISO 27701, GDPR processes, security controls, and compliance documents. - [past.dev brand guidelines](https://past.dev/brand): The marks, colors, type, and usage rules, with downloadable SVGs. - [Privacy](https://past.dev/privacy): What the site and API store, who can access the data, and how to request deletion. - [Status](https://past.dev/status): Current status of the Memory API, the console and the MCP servers, with uptime over the last 90 days. - [Incident history](https://past.dev/status/history): Every incident and maintenance window on past.dev since the status page began, with each update as it was posted. - [Terms of service](https://past.dev/terms): Accounts, acceptable use, your content, model output, fees and credits, availability, termination and liability. - [Cookie policy](https://past.dev/cookies): The cookies and browser storage past.dev uses, who sets each one, why, and for how long. - [Changelog](https://past.dev/changelog): Weekly changes to the Memory API, the console, the MCP servers and the integrations. - [Engineering guides for AI agent memory](https://past.dev/guides): Problem-space guides: changing facts, audit trails, retention, erasure, and entity resolution, each answered directly. - [Introducing past.dev: memory for AI agents](https://past.dev/blog/introducing-past-dev): past.dev, a memory layer for AI agents, is available today. An agent asks it for context and gets current facts with dated sources, limited to what it may see. - [Projects built with past.dev](https://past.dev/blog/projects): Projects that teams built with past.dev: what each one does, who built it, and how its agents use memory, with links to the code. - [Hanabi: AI agents that reproduce a biology study](https://past.dev/blog/projects/hanabi): Team Hanabi tested AI agents that reproduce a biology study from its raw data. In the swarm version, the agents share one memory on past.dev. - [Town Trial: multi-agent memory for town policies](https://past.dev/blog/projects/town-trial): Town Trial runs six agents that test a policy idea on a simulated town. past.dev is their shared memory for facts, failed ideas and audiences. - [Artificial Scientist Swarms: boredom and memory](https://past.dev/blog/projects/artificial-scientist-swarms): A research swarm measures its own boredom and changes direction. Its agents share hypotheses, results and lessons in past.dev. - [Vibe Therapist: memory for a support helper](https://past.dev/blog/projects/vibe-therapist): Vibe Therapist trains an emotional support helper with a loop of agents. past.dev holds what the agents find, and private notes for each person. - [MOM: long-term memory for the physical world](https://past.dev/blog/projects/mom): MOM answers questions such as "Where are my keys?" from the video of smart glasses. Its five agents share one memory on past.dev, and each record has a time. - [Invariant: shared memory for research agents](https://past.dev/blog/projects/invariant): Invariant runs Claude Code agents from several people on one research question. past.dev is their shared memory of papers, results and sessions. - [GPU Value Scientist: AI agents forecast GPU rents](https://past.dev/blog/projects/gpu-value-scientist): Four AI agents forecast the price to rent a GPU. Through past.dev, each agent reads what the others found before the forecast date. - [Agent memory glossary](https://past.dev/glossary): The past.dev agent memory glossary: 40 terms, each defined on its own page. - [Integrations](https://past.dev/integrations): Add past.dev memory to 22 agent frameworks and platforms, one page each. - [Comparisons](https://past.dev/compare): How past.dev compares with claude-mem, OpenMemory, Cognee, and LangMem, one page each. - [Use cases](https://past.dev/use-cases): Memory for 5 kinds of AI assistant, one page each: Productivity, Customer support, Legal and compliance, Knowledge base, and Learning and development. - [Industries](https://past.dev/industries): Memory for AI agents in 5 industries, one page each: Accounting, Healthcare, Legal AI, Financial services, and Ecommerce AI. - [Context engineering for AI agents](https://past.dev/context-engineering): Context engineering selects the instructions, tools, evidence, history and state included in each model call. Learn how to manage and measure that context. - [Vector database for RAG: how to choose one](https://past.dev/vector-database-for-rag): Compare pgvector, Pinecone, Qdrant and Weaviate for RAG by deployment, filtering, scale and hybrid search, with common retrieval failure modes. - [Vector database vs graph database vs memory](https://past.dev/vector-database-vs-memory): Compare vector, graph and relational databases with a temporal memory layer by query type, storage model, identity handling and support for changing facts. - [What is agent memory?](https://past.dev/what-is-agent-memory): Agent memory stores information across sessions and retrieves relevant parts for later model calls. Learn the main memory types, architectures and limits. - [Knowledge graph for LLM applications](https://past.dev/knowledge-graph-for-llm): How knowledge graphs support multi-hop questions, provenance and entity resolution in LLM applications, including build costs and temporal data. - [past.dev vs mem0: agent memory APIs compared](https://past.dev/vs/mem0): Compare past.dev and mem0 by storage model, input format, deployment, changed-fact handling, recall output, and operational requirements. - [past.dev vs Zep: temporal memory compared](https://past.dev/vs/zep): Compare Zep and past.dev for agent memory by temporal model, database, ingestion format, deployment, and what each recall returns. - [past.dev vs Letta: memory API or agent runtime](https://past.dev/vs/letta): Compare Letta and past.dev by agent runtime, memory control, ingestion model, deployment, and recall output. The products can also be used together. - [past.dev vs Supermemory: memory APIs compared](https://past.dev/vs/supermemory): Supermemory provides connectors and multimodal ingestion. past.dev accepts timestamped text and returns ranked documents with dated source excerpts. - [past.dev vs Graphiti: temporal memory compared](https://past.dev/vs/graphiti): Compare Graphiti and past.dev by licence, what each one asks you to operate, ingestion format, deployment, and recall output. - [past.dev vs Hindsight: agent memory compared](https://past.dev/vs/hindsight): Compare Hindsight memory and past.dev by licence, the operations each exposes, deployment, and what a recall returns. - [past.dev vs Graphon](https://past.dev/vs/graphon): past.dev vs Graphon: BEAM accuracy with a public harness, who can read what, time in each source, prices, input formats, and what a read returns. - [mem0 alternative for temporal memory](https://past.dev/mem0-alternative): past.dev is a mem0 alternative for temporal storage. Compare evidence, deployment, changed-fact handling, and tests for evaluating either system. - [Zep alternative for temporal memory](https://past.dev/zep-alternative): past.dev is a Zep alternative for temporal memory. Compare the temporal model, database, deployment, API surface, and recall output. - [Token cost calculator for your files](https://past.dev/tools/token-cost-calculator): Free token cost calculator: drop files or a folder, see token counts, what each model charges per question, and what caching or memory changes. No signup, files stay in your browser. ## Sections, one llms.txt each - [Docs](https://past.dev/docs/llms.txt): 36 pages, every one with its Markdown. By product: [Memory API](https://past.dev/docs/memory-api/llms.txt), [MCP Server](https://past.dev/docs/mcp/llms.txt), [Plugins](https://past.dev/docs/plugins/llms.txt). - [Guides](https://past.dev/guides/llms.txt): 19 pages. Engineering guides for AI agent memory: changing facts, audit trails, retention, erasure, and entity resolution. - [Glossary](https://past.dev/glossary/llms.txt): 40 pages. The past.dev agent memory glossary: 40 terms, each defined on its own page. - [Integrations](https://past.dev/integrations/llms.txt): 22 pages. Add past.dev memory to 22 agent frameworks and platforms, one page each. - [Comparisons](https://past.dev/compare/llms.txt): 4 pages. How past.dev compares with claude-mem, OpenMemory, Cognee, and LangMem, one page each. - [Use cases](https://past.dev/use-cases/llms.txt): 5 pages. Memory for 5 kinds of AI assistant, one page each: Productivity, Customer support, Legal and compliance, Knowledge base, and Learning and development. - [Industries](https://past.dev/industries/llms.txt): 5 pages. Memory for AI agents in 5 industries, one page each: Accounting, Healthcare, Legal AI, Financial services, and Ecommerce AI. - [Benchmark explainers](https://past.dev/benchmarks/llms.txt): 4 pages. What each public memory benchmark tests, and how to run and report it. - [Blog](https://past.dev/blog/llms.txt): 46 pages. Every post on the past.dev blog, newest first.