What Does AI Agent Memory Cost? A Full 2026 Breakdown
On Cognee Cloud Standard, we charge $1.00 per 1M tokens processed, plus $5 per additional workspace. Additional workspace charges are monthly. These published rates apply to our Standard plan; AI memory budgets vary with processing, queries, storage, and infrastructure. Local inference has no per-token bill but still consumes compute. This guide explains our commercial pricing, compares three modelled deployment tracks, examines vendor billing units, and shows how to estimate costs using your own workload.
What are you paying for when you add AI agent memory?
Persistent memory carries costs for processing information and retrieving context for later questions. In cognee, the four documented memory operations are remember, recall, improve, and forget. To estimate their resource cost, our local-memory guide includes indexes, embeddings, extraction, retrieval, reranking, consolidation, and the context returned to the agent. Local inference has no per-token bill, but it still consumes model time; zero model fees do not mean zero operating cost.
Source tokens, processing tokens, and retrieved context
Source tokens describe the raw corpus. Processing-token usage concerns the work performed by the memory pipeline, while retrieved-context tokens describe what is returned for an agent to use. These quantities need separate accounting: the size of a document collection alone does not establish how many tokens a particular configuration or provider will bill.
Our token-cost report models persistent-memory token usage as:
In this model, ingestion contributes an initial token cost, and each subsequent query adds retrieved context. Full-context prompting repeatedly includes corpus tokens instead. The formula provides a way to compare token usage; it does not specify every operation included in a commercial billing meter.
Provider definitions also differ. For example, Supermemory distinguishes unique ingestion tokens, search and traversal queries, and operations, and says unchanged content is not billed again. Avoid equating raw corpus tokens with billable processing tokens across vendors. Cognee Cloud bills on tokens processed by the pipeline, which this formula doesn't itemize, so use it to compare approaches rather than to calculate an exact invoice.
Why repeated queries change the AI memory budget in 2026
Repeated questions against the same corpus increase the recurring cost of supplying context. In our token-cost report, full-context prompting includes the corpus tokens on every query. Persistent memory incurs ingestion tokens upfront, then adds retrieved-context tokens for each question. As query count rises, that initial ingestion cost is spread across more requests.
The tested workloads in Cognee’s report reached break-even after approximately 23-26 repeated queries. That result applies to those corpora and configurations. It does not establish a universal threshold for persistent AI memory: the comparison depends on ingestion volume, retrieved-context size, and how often the corpus is queried.
Our cost calculator uses a separate no-memory baseline. Its agent explores a fraction of the corpus on each question, rather than sending the entire corpus every time. Cognee’s modelled estimate at default calculator inputs is approximately $10.53 per question for that exploration, with the expense recurring as questions continue year after year. The report’s full-context baseline and the calculator’s exploration baseline measure different workloads; their results cannot be substituted for each other.
The extraction configurations also differ. The token-cost report uses LLM calls for summaries and graph extraction, with local embeddings. It excludes prompt caching, incremental updates, and answer-generation completions. The calculator describes an LLM-free CPU extraction track. When estimating repeated-query costs, keep each result attached to its extraction method, context strategy, and included costs.
Three AI memory cost scenarios from Cognee's calculator
Our cost calculator compares three scenarios for a 4,093M-token corpus. All figures below are Cognee-modelled estimates at default calculator inputs, using comparison prices dated August 2026. These are scenario estimates, separate from Cognee Cloud plan prices.
| Scenario | Modelled cost | Period | Configuration and exclusions |
|---|---|---|---|
| Local/BYOC | Approximately $245 | First year | Assumes already-owned machines, with local completion using a local model. This is neither a Cognee Enterprise quote nor a complete production total cost of ownership. |
| GPT-5.5 API pipeline | Approximately $142,543 | First year | Uses GPT-5.5 as the API comparison. The calculator doesn't publish a line-item breakdown of this total. |
| No-memory exploration | Approximately $252,807 | Annually | Repeats exploration for each question, examining a fraction of the corpus rather than sending the entire corpus each time. |
Assumptions behind the estimates
Our calculator converts workload sizes into tokens using approximately 25M tokens per GB of documents, 1M tokens per repository, and 40 tokens per database row. For graph completion, it assumes approximately 1,550 input tokens plus 400 output tokens per question, with top_k=15. These assumptions affect how closely the estimates represent a particular workload.
At Cognee's default calculator inputs, modelled storage is 255.7 GB, charged at a modelled $0.08 per GB per month, or approximately $20.45 per month. Storage is a small expense in this scenario, but it is not zero. Separate Postgres instances also consume RAM, which needs to be accounted for when sizing a deployment.
Retrieval-only search carries $0 in model fees across the calculator's tracks. Local completion uses a local model; the zero-model-fee hardware scenario assumes machines are already owned. That assumption does not establish a complete operating budget: the calculator doesn't include hardware acquisition, energy, staffing, maintenance, or production-service costs.
For no-memory exploration, our calculator models approximately $10.53 per question at default inputs. That figure belongs to this specific exploration scenario; it is not a general price for an agent question. The annual cost repeats as exploration continues.
These estimates are not guaranteed costs. The calculator doesn't publish its full default query-volume and workload settings or a line-item breakdown of each total. Use the comparison to understand the scenarios, then measure a representative workload before setting a production budget.
Common challenges in estimating AI agent memory costs
An AI memory estimate depends on the extraction configuration, the source material, and the resources included in the accounting. Our token report, cost calculator, ontology guidance, and local-memory guide document different parts of that calculation. Their results need to stay attached to the configurations they describe.
Common AI memory cost-estimation problems encountered
Ingestion amplification can make source-token counts an incomplete budget input. In Cognee's token report, deliberately information-dense synthetic corpora produced ingestion multipliers of 24.6× and 23.1×. Graph extraction accounted for approximately 72-74% of ingestion tokens. Ordinary prose produced substantially less extraction output in the reported sampling, so those synthetic-workload multipliers cannot establish a universal rate for other corpora.
Mismatched extraction configurations can also distort a comparison. Our token report uses LLM calls for summaries and graph extraction; our calculator describes an LLM-free CPU extraction track. Applying the report's token multipliers directly to that local track would mix different configurations. The report also excludes prompt caching, incremental updates, and answer-generation completions, while its embeddings were local. Those boundaries limit what its totals cover.
Changed-data processing needs a separate allowance. New or changed source material can require further processing, even after the initial ingest. Cognee's ontology guide documents custom schemas and OWL/RDF inputs, alongside an improve operation that incorporates feedback, corrections, and new ingestion. This supports accounting for an evolving corpus without assuming that every document is processed only once forever. There's no fixed reprocessing rate to plan around: the cost depends on how much of the corpus changes and how often.
Uncounted local resources can leave the estimate incomplete even without a per-token invoice. Our local-memory guide notes that local inference still consumes model time. Its accounting includes indexes, embeddings, extraction, retrieval, reranking, consolidation, and context returned to the agent. A local budget should retain those resource categories: zero model fees do not mean zero total operating cost.
What to look for when comparing AI memory pricing
Compare AI memory pricing against the same workload, deployment configuration, and quality threshold. A memory-service invoice may exclude model calls or processing required after source data changes. For cognee, check the configured extraction and retrieval path before estimating model fees; installing locally does not establish an LLM-free configuration.
Necessary features for a defensible memory budget
-
Explicit usage meters. Separate source volume from ingestion work, retrieval activity, and completion costs. Ask which operations are metered and what the invoice excludes. Supermemory’s operating-cost guide recommends accounting for extraction, embeddings, searches, reranking, retries, model context, and recovery alongside new and changed content.
-
A documented deployment configuration. Record whether extraction, embeddings, and query completion use hosted models, local models, or a mixture. Our architecture guide documents embedded defaults of SQLite, LanceDB, and Ladybug, with configurable production backends. Its example also uses an API key. Any claim of zero model fees must specify the calculator’s CPU extraction configuration rather than rely on the installation location.
-
An update budget. Estimate processing for corrections and newly ingested material as well as the initial corpus. Our memory API’s
improveoperation incorporates feedback, corrections, and new ingestion. An evolving corpus can require further processing, so initial ingestion alone is insufficient for an ongoing budget. -
Resource visibility and appropriate retrieval complexity. Request enough usage detail to distinguish compute, storage, and external model charges. Check whether the task needs graph-backed retrieval: our engineering-memory guide says vector similarity search is sufficient for single-turn lookup against a small, stable corpus. Budget for the retrieval complexity the workload requires.
-
Measured task quality. Evaluate cost per successfully completed task using a defined quality rubric, as recommended by Supermemory’s operating-cost guide. Apply the same rubric to each configuration so a lower invoice is evaluated alongside whether the task was completed successfully.
How AI memory providers meter usage
Our Cognee Cloud Standard plan meters tokens processed, with a separate monthly charge for additional workspaces. Other providers count requests, Episode bytes, credits, or agent activity. Architecture alone does not determine the billing unit, so compare each meter against the workload you expect to run.
| Provider or framework | Published billing units or cost basis | Comparison caveat |
|---|---|---|
| Cognee | $1.00 per 1M tokens processed, plus $5 per additional workspace. The additional-workspace charge is monthly. | These are published Standard rates, distinct from our calculator’s modelled cost estimates. |
| Mem0 | Separate add requests and retrieval requests, with plan-specific allowances. | Account for both request meters. Graph memory is available on selected plans; describing the service as simply per-record billing omits retrieval usage. |
| Zep | Ingestion and processing credits based on Episode byte size; a separate webhook meter where available. Retrieval, storage, and users are listed as unmetered. | Graph-based processing does not imply token-based billing. Zep’s managed Context Graph Engine does not require a third-party graph database vendor. |
| Supermemory | Unique ingestion tokens, search and traversal queries, and operations, funded through plan credits. | Repeated unchanged content is not billed again. Raw corpus tokens and billable ingestion tokens are not automatically equivalent. |
| Letta | Underlying-model token usage, active-agent charges, and server-side tool execution. | Per-record pricing does not describe these API billing units. Letta also offers personal and collaborative plans. |
| Graphiti | Self-managed infrastructure, a third-party graph database, and configured inference and embedding services. | Budget for the deployed components rather than a hosted Graphiti subscription. Its documented default uses OpenAI inference and embeddings; alternative hosted providers and local model servers are supported. |
These units do not establish a cheapest-provider ranking without a measured, normalized workload comparison. In particular, Graphiti’s database requirements should not be applied to Zep’s managed platform.
For our product comparisons, read Cognee vs Mem0, Cognee vs Zep, and Cognee vs Supermemory. Those pages present our positioning; the competitor billing descriptions above use each provider’s primary documentation.
How to apply the cost model to documents, code, and enterprise memory
Document and repository workloads
Start with source volume and extraction method. Our calculator uses approximately 25 million tokens per GB of documents and 1 million tokens per repository. For a document-heavy configuration, multiply document size in GB by the document-density assumption. For a repository-heavy configuration, use repository count as the starting input. These are Cognee calculator assumptions; an estimate for your corpus should use measured token counts when available.
The extraction method also changes the processing budget. In cognee, code uses deterministic abstract syntax tree (AST) parsing, while prose uses the extraction pipeline. A repository estimate should account for that distinction rather than assuming every token requires an LLM completion.
For domain-specific memory, custom schemas and OWL/RDF ontology inputs enter the configuration alongside the source material. Specify these requirements when scoping extraction and evaluation. Source volume alone does not describe the ontology work required for a domain-specific deployment.
Local extraction and enterprise BYOC
Our calculator’s local extraction configuration uses a GLiNER2-class 205M CPU encoder. The documented measurement processes approximately 1.6 million pipeline tokens in 22 minutes on a laptop-class CPU, with zero LLM completions. This provides a reference for estimating local processing time, rather than a throughput guarantee for every corpus or machine. Deterministic code parsing should be accounted for separately from prose extraction.
For Enterprise, we scope a BYOC engagement around your ontology, evaluations on your data, and a runtime tuned to your domain inside your VPC. There is no published list price. The estimate therefore requires deployment and ontology requirements in addition to token volume; the engagement has a fixed scope rather than a calculator-derived subscription total.
Include update activity in either configuration. Cognee’s improve operation incorporates feedback, corrections, and new ingestion, and new or changed source material can require further processing. Budget for the initial corpus plus subsequent processing as the memory changes. An evolving corpus cannot be assumed to incur its entire ingestion workload only once.
Best practices for estimating your AI memory budget
Use this proposed workflow to build a workload-specific Cognee budget. It's a planning procedure rather than a measured customer result, and some steps are manual. Running it on a sample of your own data gives you the production numbers to budget against.
-
Select a representative sample. Include the source types and information density expected in production. Our token report’s deliberately information-dense synthetic corpora produced substantially more extraction output than ordinary prose. A sample dominated by dense synthetic material can distort the estimate for a prose-heavy workload.
-
Record source volume and actual processing work. Log the sample’s source volume alongside measured ingestion input and output tokens. Avoid assuming that corpus tokens equal ingestion tokens: our report measured ingestion multipliers of 24.6× and 23.1× for its synthetic corpora. Those measurements describe the tested workloads, not a universal multiplier for production data.
-
Specify the configuration being priced. Document extraction, embedding, storage, retrieval, and completion settings. Keep our token report’s LLM-based summaries and graph extraction separate from the calculator’s LLM-free CPU extraction track. The report used local embeddings; its token measurements cannot establish API embedding costs for a different configuration.
-
Estimate recurring queries separately. Budget for expected query frequency, retrieved context, reranking, and answer-generation completions independently of initial ingestion. Keep the token report’s exclusions visible: it excludes prompt caching, incremental updates, and answer-generation completions. Add workload-specific assumptions for these items rather than presenting the report as a complete operating budget.
-
Include maintenance and local resources. Allow for new and changed content, retries, and recovery alongside routine processing. For local operation, account for model time and resources used by indexes, embeddings, extraction, retrieval, reranking, and consolidation. Our local-memory guide distinguishes the absence of a per-token inference bill from the resources consumed during operation; zero model fees do not establish zero total operating cost.
-
Evaluate cost per successfully completed task. Define a quality rubric before evaluating the sample, then assess spending against tasks that meet that rubric. Supermemory’s operating-cost guide recommends this metric to account for costs beyond the memory-service invoice. Use the sample’s measured processing and task results to inform extrapolation, keeping unmeasured maintenance and usage assumptions explicit.
When persistent AI memory can justify its cost
Persistent memory can reduce repeated context processing when the same corpus is queried repeatedly and retrieval returns a bounded amount of relevant context. Our token-cost model accounts for ingestion once, then adds retrieved-context tokens for each query; full-context prompting includes the corpus again on every question. The economic case depends on whether repeated-query savings outweigh ingestion and subsequent updates. Our tested workloads do not establish a universal break-even threshold.
The extraction configuration also affects the budget. When configured for local inference, cognee avoids hosted completion charges for that processing, while still consuming model time and infrastructure resources. Resource accounting includes indexes, embeddings, extraction, retrieval, reranking, consolidation, and the context returned to the agent. Initial setup and ongoing maintenance belong in the estimate alongside query processing; zero model fees do not mean zero operating cost.
Our Apache-2.0 package is free for commercial use, removing a software-license charge. That license does not cover the resources needed to run and maintain memory. Persistent memory can justify its cost when repeated corpus use and bounded retrieval offset those expenses under the chosen configuration. There's no universal ROI figure: the return depends on your workload, query volume, and configuration.
How Cognee's Free, Standard, and Enterprise options fit the budget
Free and Standard cloud plans
Our Free plan is free forever and includes one workspace, 1M tokens, unlimited users, unlimited API calls, and integrations for Claude Code, Codex, and MCP. No credit card is required. The published plan does not specify a monthly reset for those 1M tokens, so budget against the stated allowance without assuming it renews each month.
Standard uses the token-processing rate established above, with additional workspace charges billed monthly. It adds Slack, Notion, Linear, and Google Drive integrations, repository code indexing, and in-app support. Cognee Cloud runs on gpt-oss-120b. These are published commercial terms; the calculator’s modelled estimates are separate.
Open-source deployment and Enterprise engagements
The cognee open-source package is licensed under Apache 2.0 and is free for commercial use. Install it with:
Our embedded defaults are SQLite, LanceDB, and Ladybug, with configurable production backends. Local installation alone does not establish zero model fees: the architecture guide’s example uses an API key. Any zero-model-fee estimate needs to specify the calculator’s CPU extraction configuration. Licensing, backend configuration, and model usage are separate budget considerations.
Enterprise has no published list price. We offer fixed-scope bring-your-own-cloud (BYOC) engagements lasting 6, 12, or 24 months, covering your ontology, evaluations on your data, and a domain-tuned runtime in your VPC. The 12-month package includes finetuned small models and initially bi-weekly architecture reviews. A discounted 12-month Startup package is available for pre-Series B companies; its contract price is not published.
Next steps: estimate AI memory costs on your own workload
Choose the configuration you intend to run, then measure processing on a representative sample of your workload. Record actual token counts and evaluate task results against a defined quality rubric. Use cost per successfully completed task alongside processing volume to inform the next decision.
Estimate your own cost: cognee.ai/cost-calculator. Our calculator provides modelled estimates at default inputs; use your measured workload to assess how those assumptions compare with your requirements. Keep that estimate separate from a commercial quote.
Review our plan details at cognee.ai/pricing. The Free plan includes one workspace and 1M tokens, with no credit card required, so you can evaluate a sample before committing to paid usage. If deployment requires a domain-tuned runtime in your VPC, discuss an Enterprise engagement with us. Enterprise pricing is scoped to the engagement and has no published list price.
Related guides
- Cheapest AI Agent Memory Platforms in 2026: Real Pricing Compared
- How to Cut LLM Token Costs Without Losing Context: A 2026 Guide
- Mem0 Pricing Explained: Tiers, What Is Metered, Free Tier and Alternatives
- Self-Hosted vs VPC vs Managed AI Memory: A Deployment Guide
- What is AI Memory?
FAQs About AI Agent Memory Costs
How much does Cognee Cloud cost?
Cognee Cloud Standard is $1.00 per 1M tokens processed, plus $5 per month for each additional workspace. The Free plan includes one workspace and 1M tokens with unlimited users and API calls, and no credit card is required. Enterprise is a fixed-scope bring-your-own-cloud engagement with no published list price. See the pricing page for current terms.
Is self-hosting cognee free?
The open-source package is Apache 2.0 licensed and free for commercial use, so there is no software-license charge. Running it still consumes compute for extraction, embeddings, retrieval, and storage, and any hosted model provider you configure bills separately. The calculator's LLM-free CPU extraction track is the configuration with zero model fees; a default install with an LLM API key is not.
Why do processed tokens exceed the size of my documents?
Processing tokens cover the work the memory pipeline performs, not just the raw corpus. In Cognee's token report, information-dense synthetic corpora produced ingestion multipliers of roughly 23-25x, with graph extraction accounting for most of it. Ordinary prose produced much less extraction output, so measure a representative sample of your own data rather than applying those multipliers directly.
When does persistent memory become cheaper than sending the full context every time?
In Cognee's tested workloads, persistent memory broke even with full-context prompting after about 23-26 repeated queries against the same corpus. That threshold depends on ingestion volume, retrieved-context size, and query frequency, so treat it as a reference point and run the comparison on your own workload.
