# past.dev

> Memory infrastructure for AI agents. Ingest timestamped text and query its current state.

Backed by General Catalyst, Varsity, Connect Ventures and Hummingbird.

The Memory API is in early access. The reference documents available features. The roadmap lists planned work.

## 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 must distinguish supported answers from missing evidence. /recall returns NoKnownSupport when the stored memory contains no known support.

past.dev queries only the history you ingest. It does not search the web. Send timestamped text; past.dev handles extraction, entity resolution, and storage.

## How to call it

- REST under https://api.past.dev/api/v1, bearer auth (keys start with past_sk_). Machine-readable surface description: [OpenAPI](https://past.dev/openapi.json).
- MCP (Streamable HTTP) at https://api.past.dev/mcp, manifest at [/.well-known/mcp.json](https://past.dev/.well-known/mcp.json), OAuth sign-in, no key to paste.
- Access is approved manually during early access. After approval, create project keys in the console. Request access at https://past.dev/call.
- 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`.

## Full documentation in one file
- [All docs as Markdown](https://past.dev/docs/llms-full.txt)

## Pages
- [Memory infrastructure for AI agents](https://past.dev): Ingest timestamped text and query its current state, with source evidence.
- [Documentation](https://past.dev/docs): Developer documentation for the Memory API and MCP server.
- [Pricing](https://past.dev/pricing): Four plans metered in credits, where one credit buys 350 bytes of ingested payload. Recall, storage and seats are not metered.
- [Enterprise](https://past.dev/enterprise): Run the memory API as a managed service, in a dedicated region, or inside your own infrastructure. Audited and certified for enterprise review.
- [Benchmarks](https://past.dev/benchmarks): How past.dev measures memory: BEAM, LoCoMo on corrected keys, LongMemEval, with baselines, judges, cost and latency.
- [About past.dev](https://past.dev/about): The company, founders, product principles, benchmark standards, and investors behind past.dev.
- [Contact past.dev](https://past.dev/contact): Book a call or email the past.dev team about early access, technical questions, security, or billing.
- [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.
- [Changelog](https://past.dev/changelog): Dated changes to the Memory API, MCP server, documentation, and website.
- [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](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](https://past.dev/vs/zep): Compare Zep and past.dev by temporal model, database, ingestion format, deployment, and recall output.
- [past.dev vs Letta](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](https://past.dev/vs/supermemory): Supermemory provides connectors and multimodal ingestion. past.dev accepts timestamped text and returns current-state evidence with dated sources and status.
- [What is a temporal knowledge graph?](https://past.dev/glossary/temporal-knowledge-graph): A temporal knowledge graph stores entities, relationships and facts with the time each fact was valid. Definition, structure, uses in agent memory, and how to query one.
- [What is bitemporal memory for AI agents?](https://past.dev/glossary/bitemporal-memory): Bitemporal memory tracks two timelines: when a fact was true and when the system learned it. Definition, why agents need both, and how to query each timeline.
- [What is point-in-time recall in agent memory?](https://past.dev/glossary/point-in-time-recall): Point-in-time recall returns what was true, or what was known, as of a chosen date. Definition, the queries it answers, and how temporal storage makes it possible.
- [What is fact supersession in agent memory?](https://past.dev/glossary/fact-supersession): Fact supersession replaces an outdated fact by closing its validity window and linking the successor, instead of overwriting or deleting. Definition and mechanics.
- [What is a validity window?](https://past.dev/glossary/validity-window): A validity window is the period during which a stored fact was true, with dates for when the period started and ended. Definition, mechanics, and querying.
- [What is memory decay in AI agents?](https://past.dev/glossary/memory-decay): Memory decay down-ranks, compresses, or expires old records. Definition, decay strategies, appropriate uses, and the risk of removing required evidence.
- [What is context rot and how do you prevent it?](https://past.dev/glossary/context-rot): Context rot is lower model output quality caused by stale, duplicated, conflicting, or irrelevant content in the context window. Causes and prevention methods.
- [MemoryBench: the memory benchmark, explained](https://past.dev/benchmarks/memorybench): What MemoryBench measures, how it relates to LoCoMo, LongMemEval and other agent memory benchmarks, and how to compare published results.
- [LongMemEval: what it tests and how to run it](https://past.dev/benchmarks/longmemeval): LongMemEval evaluates long-term memory in chat assistants across five abilities, including knowledge updates, temporal reasoning, and abstention. Definition and reproducible evaluation steps.
- [LoCoMo: the long-conversation benchmark, explained](https://past.dev/benchmarks/locomo): What the LoCoMo benchmark measures, the documented answer-key problem and community corrections, and how to publish comparable LoCoMo results.
- [How to benchmark agent memory](https://past.dev/benchmarks/methodology): A reproducible method to benchmark agent memory systems: test cases, baselines, judges, cost reporting, and the publication checklist that makes results comparable.
- [Memory for the Claude Agent SDK](https://past.dev/integrations/claude-agent-sdk): The Claude Agent SDK tracks session state. Add durable, temporal user history through the past.dev API.
- [LangChain memory in 2026: what replaced it](https://past.dev/integrations/langchain): LangChain deprecated its memory classes in favor of LangGraph persistence. What changed, what each option stores, and how to add temporal memory via API.
- [LangGraph memory: checkpointers, stores, and time](https://past.dev/integrations/langgraph): LangGraph memory uses checkpointers for thread state and stores for cross-thread records. Compare these functions with validity periods, supersession, and temporal recall.
- [n8n AI agent memory beyond chat history](https://past.dev/integrations/n8n): n8n's memory nodes store chat history per session. How to give n8n AI agents durable, temporal memory with two HTTP Request nodes and no custom code.
- [Temporal memory for OpenClaw](https://past.dev/integrations/openclaw): OpenClaw stores selected context in MEMORY.md and daily notes. Add queryable temporal memory through the past.dev API.
- [Point-in-time memory for accounting AI](https://past.dev/industries/accounting): Accounting AI needs balances, policies and client facts as of specific dates, with supporting evidence. Learn how a temporal memory API supports these queries.
- [Longitudinal memory for healthcare AI agents](https://past.dev/industries/healthcare): Healthcare AI agents need longitudinal context: what changed across visits, the source note behind every fact, and an insufficient-evidence status when the record is silent.
- [Memory for productivity tools and workspace assistants](https://past.dev/use-cases/productivity): Memory for productivity tools: how an assistant inside a workspace answers from meetings, documents and chat, resolves one colleague across all of them, and keeps the current decision separate from the one it replaced.
- [Memory for customer support agents](https://past.dev/use-cases/customer-support): Memory for customer support agents: how an assistant joins tickets, calls, email and billing into one customer, holds the current entitlement with its dated history, and cites the ticket behind every answer.
- [Memory for legal and compliance AI assistants](https://past.dev/use-cases/legal): Memory for legal and compliance AI: how an assistant answers which version of a clause or policy governs today, cites the document behind it, and reports when the record does not support an answer.
- [Memory for a knowledge base assistant](https://past.dev/use-cases/knowledge-base): Memory for a knowledge base assistant: how an answer over internal documentation reaches the revision in force today, cites the article behind it, and reports when the documentation does not cover the question.
- [Memory for learning and development assistants](https://past.dev/use-cases/learning): Memory for learning and development: how an assistant inside an LMS or a training product keeps a dated record of what a person has learned, stops a corrected mistake resurfacing, and traces guidance to the sessions behind it.
- [claude-mem vs past.dev](https://past.dev/compare/claude-mem): claude-mem gives Claude Code persistent session context. past.dev provides temporal memory through an API. Compare their scope, storage and use cases.
- [OpenMemory and past.dev: local memory vs memory API](https://past.dev/compare/openmemory): OpenMemory is mem0's local memory with an MCP server. Compare its deployment, browser-extension status and time model with the past.dev API.
- [Cognee vs past.dev](https://past.dev/compare/cognee): Cognee is an open-source engine that builds a knowledge graph in your infrastructure. Compare its operation and temporal model with the past.dev API.
- [LangMem and past.dev: SDK memory vs memory service](https://past.dev/compare/langmem): LangMem manages long-term memories over the LangGraph store. Compare its responsibilities, storage model and operation with the past.dev API.
- [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.
- [Overview: What the Memory API is](https://past.dev/docs/memory-api/overview) ([Markdown](https://past.dev/docs/memory-api/overview/llms.txt)): Send text to past.dev and query the memory it creates.
- [Quickstart](https://past.dev/docs/memory-api/quickstart) ([Markdown](https://past.dev/docs/memory-api/quickstart/llms.txt)): Send a fact and its update, wait for ingestion to finish, then query the current value.
- [Authentication](https://past.dev/docs/memory-api/authentication) ([Markdown](https://past.dev/docs/memory-api/authentication/llms.txt)): Use one bearer key for each project.
- [How it works](https://past.dev/docs/memory-api/how-it-works) ([Markdown](https://past.dev/docs/memory-api/how-it-works/llms.txt)): Ingestion ordering, idempotency, entity resolution, and recall status affect application behavior.
- [API reference: Endpoint reference](https://past.dev/docs/memory-api/api-reference) ([Markdown](https://past.dev/docs/memory-api/api-reference/llms.txt)): Four available endpoints under /api/v1, followed by planned endpoints. Field names match the API request and response fields.
- [Errors](https://past.dev/docs/memory-api/errors) ([Markdown](https://past.dev/docs/memory-api/errors/llms.txt)): A JSON body with code, status, debugMessage and data. Match on the code.
- [Self-hosting](https://past.dev/docs/memory-api/self-hosting) ([Markdown](https://past.dev/docs/memory-api/self-hosting/llms.txt)): Run the API, console and storage on your infrastructure with Docker Compose. Self-hosted deployments use the same engine and container images as the managed service.
- [Roadmap](https://past.dev/docs/memory-api/roadmap) ([Markdown](https://past.dev/docs/memory-api/roadmap/llms.txt)): Current availability and planned API work.
- [Overview: What the past.dev MCP server is](https://past.dev/docs/mcp/overview) ([Markdown](https://past.dev/docs/mcp/overview/llms.txt)): Connect an MCP client to your past.dev account to inspect and add memories while developing an integration.
- [Quickstart: Connect an MCP client](https://past.dev/docs/mcp/quickstart) ([Markdown](https://past.dev/docs/mcp/quickstart/llms.txt)): Add the server URL to your client, then sign in through your browser. No API key is required.
- [Tool reference: Available tools](https://past.dev/docs/mcp/tool-reference) ([Markdown](https://past.dev/docs/mcp/tool-reference/llms.txt)): The server provides two tools for memories in your past.dev account. Both use your identity and permissions.
- [Serving your own users: Use past.dev with your product's users](https://past.dev/docs/mcp/serving-your-own-users) ([Markdown](https://past.dev/docs/mcp/serving-your-own-users/llms.txt)): Run your own MCP server over the Memory API. Your application continues to manage user identity and access.
- [How it works](https://past.dev/docs/mcp/how-it-works) ([Markdown](https://past.dev/docs/mcp/how-it-works/llms.txt)): past.dev verifies identity and permissions on every request. The client receives only the tools permitted for the signed-in user.
- [Security](https://past.dev/docs/mcp/security) ([Markdown](https://past.dev/docs/mcp/security/llms.txt)): The server uses short-lived OAuth tokens. It derives permissions and workspace access from server-side records on every request.
- [Admin controls: Administrative controls](https://past.dev/docs/mcp/admin-controls) ([Markdown](https://past.dev/docs/mcp/admin-controls/llms.txt)): Available administrative controls, unavailable controls, and current alternatives.
- [Privacy & compliance: Privacy and compliance](https://past.dev/docs/mcp/privacy-compliance) ([Markdown](https://past.dev/docs/mcp/privacy-compliance/llms.txt)): The MCP server uses the same security and privacy controls as the rest of past.dev.
- [Limits: Limits and known behaviour](https://past.dev/docs/mcp/limits) ([Markdown](https://past.dev/docs/mcp/limits/llms.txt)): Current MCP behavior and product limitations.
- [Troubleshooting](https://past.dev/docs/mcp/troubleshooting) ([Markdown](https://past.dev/docs/mcp/troubleshooting/llms.txt)): Check the server URL, authentication, workspace membership, and available tools.
- [FAQ: Questions](https://past.dev/docs/mcp/faq) ([Markdown](https://past.dev/docs/mcp/faq/llms.txt)): Common questions about access, administration, cost, and setup.

## Blog

- [What is a company brain? Timeline and requirements](https://past.dev/blog/company-brain) ([Markdown](https://past.dev/blog/company-brain.md)) (2026-08-30, Research): A definition of the company brain, its main components, and the memory functions required to keep company information current.
- [Giving AI agents a past](https://past.dev/blog/giving-ai-a-past) ([Markdown](https://past.dev/blog/giving-ai-a-past.md)) (2026-08-30, Research): AI agents start every run without a past. What giving AI a past means: event time, sources, supersession, and how agents track the past accurately.
- [What is an LLM wiki and where does it break?](https://past.dev/blog/llm-wiki) ([Markdown](https://past.dev/blog/llm-wiki.md)) (2026-08-30, Research): A definition of the LLM wiki, a standard implementation using Markdown and git, and its limitations for facts that change.
- [Mem0 alternatives for agent memory in 2026](https://past.dev/blog/mem0-alternatives) ([Markdown](https://past.dev/blog/mem0-alternatives.md)) (2026-08-30, Engineering): A comparison of mem0 alternatives including Zep, Letta, Supermemory and past.dev by architecture, deployment, inputs and changed-fact handling.
- [What agentic memory is and how to build it](https://past.dev/blog/agentic-memory) ([Markdown](https://past.dev/blog/agentic-memory.md)) (2026-08-28, Research): Agentic memory explained: the four memory types, why agents need storage outside the context window, and how a temporal knowledge graph works.
- [How AI agents read a website](https://past.dev/blog/website-agents-can-read) ([Markdown](https://past.dev/blog/website-agents-can-read.md)) (2026-08-26, Engineering): How AI agents read a website through HTML, Markdown, llms.txt and MCP interfaces, with tests for every published format.
- [How we benchmark memory](https://past.dev/blog/measuring-memory-honestly) ([Markdown](https://past.dev/blog/measuring-memory-honestly.md)) (2026-08-25, Research): How past.dev benchmarks memory with corrected answer keys, strong baselines, multiple judges, and cost reported with accuracy.