v0.9 — early access

The cognitive memory layer for stateful AI agents.

Classify, persist, and reconcile every signal your agents encounter. Detects contradictions, maintains audit trails, and remembers what's true, what's wrong, and what's still uncertain.

Book a demo →Read the docs

~5ms

ANN search

Confidence tiers

$0.0003

Per classification

85%+

Accuracy

agent.py

from persistx import CognitiveClient

memory = CognitiveClient(

"https://api.persistx.ai",

tenant_id="healthcore-001"

)

# Assessed, screened, and stored in one call

result = memory.assess(

user_id="care-bot-01",

content="BP 142/88 mmHg — elevated, flagged for review",

source="CLINICAL_NOTE"

)

# → confidence: 0.91

# → drift: false

# → tracking_id: "7f3a9c..."

# Retrieve what the agent remembers

context = memory.recall(

user_id="care-bot-01",

query="patient blood pressure history"

)

# → 3 memories surfaced

# → 1 conflict auto-resolved

The problem

Stateless agents fail in three predictable ways.

Every production team eventually hits the same wall: LLMs forget, contradict themselves, and can't tell knowledge from speculation. Vector DBs and chat history don't fix this — they store text, not meaning.

01 / Forgetting

Context windows aren't memory.

Agents lose 80% of their reasoning when the conversation rolls off the context window. Summarization tools paper over the problem — they don't preserve what was verified vs what was speculated.

02 / Contradiction

No system tracks what changed.

When new information contradicts old, agents either silently overwrite, blindly trust the latest, or hallucinate a synthesis. Production needs an audit trail of why a belief changed.

03 / Trust collapse

Knowledge and speculation look identical.

Vector retrieval returns "Customer churned because of pricing" with the same confidence whether it was directly observed, inferred, or hallucinated three turns ago. Downstream reasoning compounds the error.

How it works

Cognitive memory, end to end.

persistX classifies every signal your agent observes, reconciles it against what's already known, and returns only what's verified and relevant. One pipeline. One API.

Agent observations

Tool outputs

User signals

Cognitive engine

Classify✓

Reconcile✓

Persist✓

Verified context

Reconciled history

Audit trail

Ingest

A single call. No schemas.

Every signal your agent observes — tool outputs, user input, retrieved documents — flows in through one ingest() call. persistX figures out what to do with it.

Reconcile

Contradictions, surfaced and scored.

The cognitive engine classifies each signal against existing memory and detects contradictions. Every result carries a confidence score and a full audit trail.

Retrieve

Verified context, on demand.

When your agent needs context, persistX returns only what's verified and relevant. No contradictions, no stale facts. Token-efficient, ready for the LLM.

How persistX compares

Memory that thinks, not just stores.

Vector databases retrieve. RAG frameworks orchestrate. Memory layers persist. persistX does the cognitive work in between— so your agent doesn't have to.

Capability profile

Cognitive context, by dimension.

persistX5.2 / 6.0

Memory layer3.6 / 6.0

RAG framework2.7 / 6.0

Vector DB only1.6 / 6.0

Equal-weighted average across the six dimensions, normalized to a 0–6 scale. See methodology →

What the shape shows

persistX's shape pulls outward on every axis because it does the cognitive work other categories leave to you. The other shapes leave gaps — that's where developers end up writing custom logic.

Side by side

Capability checklist.

	Vector DB	RAG	Memory layer	persistX
Knows what it knows	—	basic	partial	✓
Catches conflicting facts	—	—	limited	✓
Traceable answers	—	basic	partial	✓
Forgets what's no longer relevant	—	—	—	✓
Returns just the right context	raw	basic	partial	✓
One API. No infra.	—	framework	✓	✓
/ Memory
Continuity across sessions	—	manual	✓	✓
Time-bound recall	—	—	limited	✓
Avoids duplicate memories	—	—	basic	✓
/ Reconciliation
Confidence-aware retrieval	—	—	limited	✓
Handles “this is no longer true”	—	—	—	✓
Tunable forgetting policy	—	—	—	✓
/ Operations
Cross-agent memory queries	raw	—	limited	✓
Type-aware ingestion	—	manual	partial	✓
Hierarchical context expansion	—	manual	limited	✓

Comparison reflects typical baseline implementations across each category. Memory-layer category includes general-purpose persistence products without cognitive reconciliation. Scores normalized 0–6 across six equal-weighted dimensions. Read how we scored this →

Quickstart

Drop in. Three lines. Stateful agent.

Works with any agent framework. Use the Python client, the LangGraph node, or connect Claude Desktop directly via MCP.

from persistx import CognitiveClient

memory = CognitiveClient("https://api.persistx.ai", api_key="px_...")

# Classify and persist

unit = memory.ingest(agent_id="agent-1", content="User churned because pricing changed.")

# Retrieve as formatted prompt context

ctx = memory.get_context(agent_id="agent-1", query="Why did users churn?")

Built for

Memory that travels with your agents.

Wherever your agents work — support, sales, research, code, regulated workflows — persistX gives them the memory they need to stay sharp across sessions, channels, and time.

Customer experience platforms

Conversations reset between sessions. Returning customers re-explain context. Agents re-summarize prior turns into every prompt, inflating cost per resolution.

Every interaction inherits the full history. Customers pick up where they left off — across channels, across human handoffs, across weeks of silence.

Cross-session continuity

support_agent.py

# Customer returns 3 weeks after last contact —# persistX returns the full prior conversation context = memory.recall(    agent_id="support-tier-1",    customer_id="cust_8a3f",    scope="all_sessions",) # → 4 prior tickets, 2 unresolved threads# → 1 verified preference (no SMS)# → handoff history with 2 agents

Don't see your use case?

If your agent forgets things, persistX probably solves it.

Talk to an engineer →

Pricing

Predictable pricing. Scales as you grow.

Pay for what your agents actually remember. No per-seat licensing, no hidden fees, no surprise overage bills.

Build with us. Build the memory together.

Our first 10 customers won’t buy a finished product — they’ll shape one. In exchange for honest feedback and a real production workload, we’re offering an entire year of persistX at a fraction of list price.

$399

one-time12 months · up to 1M ops/month

What you get

Every premium feature unlocked from day one
Direct line to founders via private Slack
Roadmap input — the features you ask for ship first
Co-authored case study when you’re ready to publish
Founding partner badge on our launch wall

Apply for a spot →

Foundation

For teams shipping their first stateful agent.

$59/month

50,000 memory operations included.
Then $15 per additional 10,000.

50,000 ops per monthAuto-topup at 20%. 30-day rollover.
500 requests / minute
3 projects
API logs (1 day)
Unlimited memories, retrieval & users
Community Slack support

Get started →

Scale

For agents in production at scale.

$199/month

250,000 memory operations included.
Then $50 per additional 50,000.

250,000 ops per monthAuto-topup at 20%. 60-day rollover.
2,000 requests / minute
10 projects
Tunable forgetting policies
Webhooks & usage analytics
API logs (7 days)
Email & Slack support