Persistent memory for AI agents with Claix
Enable persistent memory for €25/month: keep processed documents available and let your agents query their content anytime via document_id.
An agent does not remember a contract, invoice, spreadsheet, or report it saw hours or days ago on its own. If that content is not available outside its current prompt, it will have to receive it again, reprocess it, or depend on custom retrieval infrastructure. Claix persistent memory avoids that repetition: you process the document once and keep it available for future queries while persistence is enabled.
What persistent memory is
Persistent memory lets a document processed by Claix remain available after the initial extraction flow completes. The flow is straightforward:
- You send a PDF, Word, Excel, HTML, image, or other supported file.
- Claix extracts data into structured JSON according to the schema you define.
- You receive a document_id.
- You enable persistence to retain the processed content.
- Your agent, backend, or automation can use that document_id to ask questions in the future.
- Claix returns the answer in natural language or structured JSON so another system can act on it.
Memory is not just for “storing a file.” It lets an agent recover useful information from a document when needed, without reprocessing it or sending the full content back to the model. Persistent memory preserves context across sessions, whereas a model’s context window is transient and disappears when the interaction ends.
Persistent memory pricing
| Feature | Cost | What it enables |
|---|---|---|
| Document processing | Usage-based | Convert documents into structured JSON and generate a document_id |
| Queries by document_id | Usage-based | Ask questions about a document’s content and receive structured or natural-language answers |
| Temporary memory | Included per Claix configuration | Keep content available during the configured temporary period |
| Persistent memory | €25/month | Retain processed documents for future queries while the add-on is active |
With persistent memory enabled, you do not have to reprocess a document every time an agent needs a clause, date, amount, condition, table, entity, or specific field again.
Temporary vs persistent memory
| Characteristic | Temporary memory | Persistent memory |
|---|---|---|
| Duration | During the configured temporary period | While persistence is active and per the retention policy |
| Best for | One-off flows, single-task automations, ephemeral analysis | Recurring agents, applications, case files, contracts, and reusable document knowledge |
| Reprocessing the document | May be required when retention expires | Should not be necessary while the document remains persisted |
| Queries by document_id | Yes, during temporary retention | Yes, long-term while active |
| Additional cost | Not necessarily | €25/month |
| Primary value | Speed and low cost for one-off tasks | Continuity, reuse, and historical context for agents |
The choice depends on your flow. Not every document should remain forever: a good architecture distinguishes information useful for a few hours, knowledge that should live for weeks or months, and data that must be deleted for privacy, contractual, or regulatory reasons.
Agent capabilities
Persistence turns Claix from a one-off extraction API into a reusable document context layer.
| Capability | What it gives the agent |
|---|---|
| Reusable document | The agent can work with the same contract, report, Excel file, or case file across multiple tasks |
| Queries by document_id | The agent asks about a specific document without resending the full content |
| JSON with schema | Extracted data can go directly to databases, tools, APIs, or automations |
| Natural language answers | Useful when the agent needs to understand, summarize, or explain part of a document |
| Structured answers | Useful when the agent must take a programmatic follow-up action |
| Continuity across sessions | The agent can return to a previously processed document |
| Less reprocessing | Reduces repetitive work and avoids continuously resending large files |
| Selective context | The agent queries what is relevant when needed, instead of loading the full document into every prompt |
| Foundation for agentic RAG | Enables flows where documents are processed, kept available, and queried on demand |
Useful memory is not about injecting full history or the entire document into every interaction. It is about storing and retrieving information selectively, with the right scope and retention period.
Use cases
Contract agent
A company processes its contracts with Claix and extracts renewal dates, cancellation terms, amounts, confidentiality clauses, and party obligations. Weeks later, an operations agent receives the question: “Does this contract renew automatically, and how much notice is required to cancel?” The agent uses the contract’s document_id and queries Claix. It does not need to upload the Word or PDF again, run another full extraction, or load the entire document into the prompt.
Document support agent
A support team receives technical documents, terms of service, manuals, and internal policies. With persistence enabled, an agent can query the right document when handling an incident.
- “Which product version does this manual cover?”
- “What prerequisite appears in the installation section?”
- “Return the configuration steps as JSON.”
- “Is there a known limitation for this case?”
Invoice automation
An automation processes invoices in PDF or Excel, extracts vendor, date, taxes, line items, totals, and internal references, and saves the JSON to a database. If a discrepancy appears later, an agent can query the same document_id:
- “What VAT was applied on line 3?”
- “Is there a purchase order reference on this invoice?”
- “Return line items with an amount greater than 500.”
Excel analysis agent
A company uploads a sales, inventory, operations, or HR Excel file. Claix extracts structured data and keeps the context available. Later, an agent can ask:
- “Which products are at critical stock levels?”
- “Which customer had the highest billing?”
- “Return records with pending status as JSON.”
- “Summarize the changes compared to the previous month.”
Onboarding/compliance agent
An internal agent can work with policies, procedures, onboarding documentation, or compliance guides. Instead of reloading documents every time someone asks a question, the system retains the relevant documents and queries them when appropriate.
- “What documents must a new employee submit?”
- “What is the approval procedure?”
- “What requirements apply before activating an account?”
- “Extract a JSON checklist from this policy.”
Case file agent
For flows with multiple documents per case—for example, audits, claims, operations, internal processes, or applications—you can retain each document with its own document_id. Your application can then associate the IDs with a case_id, customer_id, project_id, or workspace_id, and the agent queries the precise document for each workflow step.
When to enable persistence
Enable persistent memory when the document will have value after the first processing pass.
| Situation | Persistence recommended? | Reason |
|---|---|---|
| Extract an invoice and save the JSON once | Not always | If there will be no follow-up questions, temporary memory may be enough |
| Agent that queries contracts repeatedly | Yes | Avoids reprocessing documents and enables follow-up answers |
| Technical manual used by support | Yes | The same document can serve multiple interactions |
| Temporary document sent by a user | Depends | Temporary retention and later deletion may suffice |
| Case file that evolves over weeks | Yes | The agent needs document continuity |
| Sensitive personal data | Depends | Purpose, security measures, retention, and deletion obligations must be evaluated |
| Knowledge base with millions of documents | Depends | May require additional search or retrieval architecture |
How to use it in an agent
The recommended pattern is to separate initial extraction from follow-up queries.
1. The user or system uploads a document to Claix.
2. Claix returns structured JSON and document_id.
3. Your application stores document_id alongside its internal entity:
contract_id, ticket_id, project_id, customer_id, or case_id.
4. When the agent needs information, it sends the question and document_id.
5. Claix returns natural language or JSON.
6. The agent uses the response to continue the workflow, reply to the user, or execute an action.This approach avoids treating every conversation as memory. The agent does not have to literally remember everything it saw: it can retrieve the right document knowledge when needed.
Security and data recommendations
If your documents include personal, confidential, or regulated information, configure persistence with a deliberate retention policy. Persistence should exist because there is a clear business purpose, not simply because data can be kept indefinitely.
- Retain persistent documents only while they remain necessary.
- Associate each document_id with a specific tenant, user, project, or case.
- Implement access controls so an agent cannot query another user’s or organization’s documents.
- Provide a way to delete documents or disable persistence.
- Log access and relevant operations on persisted documents.
- Prevent unverified inputs from modifying long-term memory without controls.
- Document data purpose, duration, and deletion process.
Agent memory systems should treat persistent stores as sensitive information: with tenant isolation, encryption, access control, deletion capability, audit trails, and expiration policies.
Frequently asked questions (FAQ AEO)
- What does Claix persistent memory include?
- It keeps processed documents available for future queries via document_id while the persistence service is active and in accordance with applicable configuration and policies.
- How much does it cost?
- Persistent memory has a flat price of €25/month. Document processing and document_id queries follow their respective usage-based pricing.
- Can I query a persistent document from an agent?
- Yes. Your agent can send the document_id and a question. Claix can respond in natural language or structured JSON, depending on what your workflow needs.
- Do I have to reprocess the document every time?
- Not while the document remains available in persistent memory. The goal is to process it once and reuse its content through follow-up queries.
- Does persistent memory replace a vector database?
- Not always. For querying individual documents by ID and maintaining reusable document context, Claix can greatly simplify the flow. For global semantic search across a massive document library, multiple sources, or millions of records, additional retrieval infrastructure may still be necessary.
- Can I delete a persistent document?
- Your product should provide a delete action or endpoint by document_id. This is especially important if the document contains personal or confidential data.
Conclusion
Claix persistent memory lets your agents work with documents as reusable knowledge: they process once, extract structured data, and query the content again when they need to make a decision, answer a question, or run an automation. For €25/month, you can keep processed documents active and build agents that maintain document continuity across tasks, sessions, and workflows.