# 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`. ## Integrate in two calls Write any text with its original timestamp, then query it. Poll the ingestion until `settled` is true before expecting recall to reflect it. ```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"}' 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?"}' ``` Recall returns ranked, dated evidence with sources and a status of `Supported`, `Conflicted`, `NoKnownSupport`, or `UnknownBecauseDegraded`. MCP clients can skip REST entirely: ```json { "mcpServers": { "pastdev": { "type": "http", "url": "https://api.past.dev/mcp" } } } ``` ## 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. - [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. - [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. - [What is event time?](https://past.dev/glossary/event-time): Event time is when something happened in the world, taken from the source's own timestamp. How it differs from ingestion time, with a backfill example. - [What is ingestion time?](https://past.dev/glossary/ingestion-time): Ingestion time is when a system received a piece of data, distinct from the event time of what it describes. Definition, uses, and a backfill example. - [What is data provenance?](https://past.dev/glossary/data-provenance): Data provenance is the record of where information came from and how it changed: source, custody, transformations. Definition and why AI agents need it. - [What is fact extraction?](https://past.dev/glossary/fact-extraction): Fact extraction turns raw text into structured facts: subject, value, and the time each applies to. Definition, pipeline steps, and a worked example. - [What is a knowledge update?](https://past.dev/glossary/knowledge-update): A knowledge update replaces a stored fact's value when the world changes, keeping predecessors distinguishable. How supersession works, with an example. - [What is temporal reasoning?](https://past.dev/glossary/temporal-reasoning): Temporal reasoning answers questions whose truth depends on time: current state, past state, order of events. The question types and what memory needs. - [What is event ordering?](https://past.dev/glossary/event-ordering): Event ordering places stored events in the sequence they happened, by event time rather than arrival. Why records arrive out of order and what fixes it. - [What is memory staleness?](https://past.dev/glossary/memory-staleness): Memory staleness is stored information that no longer matches the world because it was never updated. How it differs from decay, and how to detect it. - [What is an audit trail in AI agents?](https://past.dev/glossary/audit-trail): An audit trail records what an AI agent knew, from which sources, at what time, so past actions can be explained. Definition and what to log. - [What is a data retention policy?](https://past.dev/glossary/data-retention): A data retention policy sets how long each class of stored data is kept and what removes it. What it covers for AI agent memory, with an example schedule. - [What is a knowledge cutoff?](https://past.dev/glossary/knowledge-cutoff): A knowledge cutoff is the date a model's training data ends. Why models miss newer facts and how retrieval and memory supply them, with dates and sources. - [What is episodic memory in AI agents?](https://past.dev/glossary/episodic-memory): Episodic memory lets an AI agent store specific dated events and recall what happened, with the time, context, and source of each event. - [What is semantic memory in AI agents?](https://past.dev/glossary/semantic-memory): Semantic memory stores an AI agent's general facts: plans, owners, preferences. How facts are distilled from events and kept current as they change. - [What is procedural memory in AI agents?](https://past.dev/glossary/procedural-memory): Procedural memory stores how an AI agent performs tasks: the steps, rules, and workflows it applies without re-deriving them each session. - [What is working memory in AI agents?](https://past.dev/glossary/working-memory): Working memory is what an AI agent holds in the context window during one task: what it contains, its limits, and its link to long-term storage. - [What is long-term memory in AI agents?](https://past.dev/glossary/long-term-memory): Long-term memory gives an AI agent knowledge that persists across sessions: what belongs in it, how recall works, and why it needs dates. - [What is recall in AI agents?](https://past.dev/glossary/recall): Recall is the operation that returns stored memory relevant to a query, ranked and dated. How AI agents recall facts with evidence and sources. - [What is recall precision?](https://past.dev/glossary/recall-precision): Recall precision is the share of returned memory that is relevant to the query. Why it matters for AI agents and what improves it. - [What is abstention in AI agents?](https://past.dev/glossary/abstention): Abstention is a system declining to answer when evidence is missing rather than guessing. Why AI agents need it and how the signal works. - [What is an evidence status?](https://past.dev/glossary/evidence-status): An evidence status labels every recall response: supported, conflicted, or no known support. The four status values and what agents do with each. - [What is hybrid retrieval?](https://past.dev/glossary/hybrid-retrieval): Hybrid retrieval combines semantic similarity with exact keyword and identifier matching so queries match both meaning and exact ids. - [What is grounding in AI agents?](https://past.dev/glossary/grounding): Grounding ties an AI agent's answers to verifiable sources, so every claim traces to dated evidence. How grounded recall works in practice. - [What is entity resolution?](https://past.dev/glossary/entity-resolution): Entity resolution defined: linking records that refer to the same real-world entity, and how it differs from identity and coreference resolution. - [What is identity resolution?](https://past.dev/glossary/identity-resolution): Identity resolution defined: connecting one person's identifiers across channels and sessions so an agent recognizes a returning user. - [What is coreference resolution?](https://past.dev/glossary/coreference-resolution): Coreference resolution defined: linking mentions inside one text to their referents, and why memory pipelines run it before entity resolution. - [What is a memory graph?](https://past.dev/glossary/memory-graph): A memory graph stores agent knowledge as entities and dated relationships. Definition, contrast with vector stores, and the temporal variant. - [What is vector memory?](https://past.dev/glossary/vector-memory): Vector memory defined: storing text as embeddings and retrieving by similarity, what it does well, and what it cannot track by itself. - [What is memory consolidation in AI agents?](https://past.dev/glossary/memory-consolidation): Memory consolidation defined: the background reprocessing that merges duplicates, resolves entities, and updates structure after ingestion. - [What is session memory?](https://past.dev/glossary/session-memory): Session memory defined: what an AI agent retains within one conversation, why it disappears when the session ends, and how it becomes persistent. - [What is cross-session memory?](https://past.dev/glossary/cross-session-memory): Cross-session memory defined: how AI agents keep information between conversations so a returning user is recognized with full history. - [What is a context window?](https://past.dev/glossary/context-window): Context window defined: the token-bounded text an LLM can attend to in one call, what the limit means in practice, and how it differs from memory. - [What is memory poisoning?](https://past.dev/glossary/memory-poisoning): Memory poisoning defined: how malicious or mistaken inputs corrupt agent memory and later surface as trusted facts, and the standard defenses. - [What is a memory API?](https://past.dev/glossary/memory-api): A memory API defined: the interface for writing records with timestamps, polling settlement, recalling with evidence, and deleting by source. - [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. - [Matter-aware memory for legal AI](https://past.dev/industries/legal): Why legal AI needs matter memory: who said what and when with the source document, entity resolution for conflicts checks, and recall scoped by audience. - [Auditable memory for financial services AI](https://past.dev/industries/financial-services): Financial services AI must answer what was known when. Point-in-time recall, supersession, provenance and retention make agent memory reviewable. - [Customer memory for ecommerce AI](https://past.dev/industries/ecommerce): How ecommerce AI remembers one customer across storefront, email, chat and returns: identity resolution, changing sizes and seasonal facts that expire. - [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. - [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. - [How to handle facts that change over time](https://past.dev/guides/facts-that-change-over-time): How a memory system stores facts that change over time: overwrite vs append-only vs supersession, with a worked example and an evaluation checklist. - [Bitemporal data, explained for AI systems](https://past.dev/guides/bitemporal-data): Bitemporal data tracks valid time and transaction time. What each axis records, the four query types they answer, and why agent memory needs both. - [Temporal databases and AI agent memory](https://past.dev/guides/temporal-database): What a temporal database records beyond current state, the main implementations, and what AI agent memory needs on top of temporal tables. - [Data provenance for AI agents](https://past.dev/guides/data-provenance): Data provenance records where a piece of data came from, who held it, and what transformed it. Why agent memory needs it for citation, audit, and deletion. - [When an AI agent holds contradictory facts](https://past.dev/guides/contradictory-facts): Contradictory facts in AI memory come in two kinds: a value that changed, and sources that disagree. How to detect each case and resolve it without guessing. - [Event time vs ingestion time in AI memory](https://past.dev/guides/event-time-vs-ingestion-time): Event time vs ingestion time: why AI memory must order facts by when things happened rather than when they were imported, and how to backfill history safely. - [Designing a forgetting policy for AI agents](https://past.dev/guides/forgetting-policy): A forgetting policy decides what an AI agent forgets, and how: supersession, decay or eviction, retention expiry, or erasure, chosen per data type. - [Entity resolution for AI agent memory](https://past.dev/guides/entity-resolution): What entity resolution is, how deterministic and probabilistic entity matching work, and why agent memory must resolve entities at ingestion. - [Identity resolution across sessions and channels](https://past.dev/guides/identity-resolution): How identity resolution joins emails, phone numbers, user ids and anonymous sessions into one profile, so an AI assistant keeps cross-channel context. - [How to merge duplicate profiles in AI memory](https://past.dev/guides/merge-duplicate-profiles): How to merge duplicate profiles without losing history: merge vs link, survivorship rules, provenance for undo, and monitoring after the merge. - [Testing entity resolution in agent memory](https://past.dev/guides/testing-entity-resolution): A working method for testing entity resolution: a gold set built from your identifier matrix, five standard cases, and an end-to-end assertion. - [Audit trail for AI agent decisions](https://past.dev/guides/ai-audit-trail): An AI audit trail records what an agent knew when it acted: facts, sources, dates. What to log, and how to reconstruct a past knowledge state. - [The right to be forgotten in AI agent memory](https://past.dev/guides/gdpr-memory-deletion): GDPR Article 17 gives people the right to be forgotten. What erasure means for AI agent memory, where derived facts hide, and how deletion by source works. - [Data retention policies for AI memory](https://past.dev/guides/ai-data-retention): A data retention policy states how long an AI system keeps each class of stored information and what happens at expiry. How to classify, enforce, and verify. - [EU AI Act record-keeping for AI agents](https://past.dev/guides/eu-ai-act-record-keeping): The EU AI Act requires record keeping for high-risk AI systems. What Articles 12, 19 and 26 ask for, and what agent memory must support to answer them. - [How to choose a memory system for AI agents](https://past.dev/guides/choose-memory-system): A rubric to choose a memory system for AI agents: the five tests to run on your own data, the criteria that separate architectures, and when to buy nothing. - [Building an AI assistant that remembers users](https://past.dev/guides/ai-assistant-that-remembers): An AI assistant that remembers users needs identity resolution, facts that update, and deletion that holds. The architecture, and the two calls that run it. - [Memory observability for AI agents](https://past.dev/guides/memory-observability): Memory observability answers why an agent retrieved what it did: what to log at ingestion and recall, how to trace a wrong answer, and what to alert on. - [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 - [How ChatGPT Memory Works](https://past.dev/blog/chatgpt-memory) ([Markdown](https://past.dev/blog/chatgpt-memory.md)) (2026-09-02, Research): How ChatGPT memory works as of September 2026: saved memories, reference chat history, the memory summary, what memory full means, and how to clear it. - [Claude Code Memory: How CLAUDE.md Actually Works](https://past.dev/blog/claude-code-memory) ([Markdown](https://past.dev/blog/claude-code-memory.md)) (2026-09-02, Research): How Claude Code memory works: the CLAUDE.md hierarchy, auto memory files and caps, session resumption, and where file-based facts go stale. - [Claude Memory: How It Works and What It Stores](https://past.dev/blog/claude-memory) ([Markdown](https://past.dev/blog/claude-memory.md)) (2026-09-02, Research): How Claude memory works in September 2026: what gets stored, project scoping, plan availability, user controls, and the limits Anthropic documents. - [How Copilot Memory Works: Microsoft and GitHub](https://past.dev/blog/copilot-memory) ([Markdown](https://past.dev/blog/copilot-memory.md)) (2026-09-02, Research): Copilot memory means two different systems. A teardown of Microsoft Copilot and GitHub Copilot memory: storage, retention, controls, deletion. - [How Cursor Memory Works: Rules and Memories](https://past.dev/blog/cursor-memory) ([Markdown](https://past.dev/blog/cursor-memory.md)) (2026-09-02, Research): Cursor memory from the official docs: rules vs the memories feature, what persists across chats and machines, plus controls, deletion, limits. - [How Gemini Memory and Personalization Work](https://past.dev/blog/gemini-memory) ([Markdown](https://past.dev/blog/gemini-memory.md)) (2026-09-02, Research): How Gemini memory works as of September 2026: past chat recall, Instructions for Gemini (saved info), Personal Intelligence, and deletion controls. - [What a good AI memory benchmark measures](https://past.dev/blog/ai-memory-benchmark-guide) ([Markdown](https://past.dev/blog/ai-memory-benchmark-guide.md)) (2026-09-01, Research): An AI memory benchmark must test changing facts, ordering, and abstention on complete splits. The ten abilities, and what to demand from any score. - [Cutting LLM token costs with memory](https://past.dev/blog/llm-token-costs) ([Markdown](https://past.dev/blog/llm-token-costs.md)) (2026-09-01, Research): LLM token costs scale with how much history you send per question. The arithmetic of context stuffing, what caching changes, and what memory changes. - [How memory accuracy degrades with scale](https://past.dev/blog/memory-accuracy-at-scale) ([Markdown](https://past.dev/blog/memory-accuracy-at-scale.md)) (2026-09-01, Research): Memory accuracy measured at 100K, 500K, 1M and 10M events: the published splits, which abilities hold at scale, and where systems actually lose accuracy. - [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.