Dev cost run (verified path): Median query tokens 83 (Eidetic) vs 382 (Mem0)
Problem: AI memory retrieves context and answers anyway, so agents sound confident while inventing facts, dropping old information, and giving you no way to tell a real memory from a guess.
Solution: Eidetic only answers from stored evidence or stays silent: on eight holdout windows (n=320) that's 182/320 vs Mem0 140/320, 277 verified answers vs 0, and 25/60 vs 3/60 on when-did-this-happen questions.
Qwen Cloud Integration
How it fits together
| Name | What it is | What you use today |
|---|---|---|
| Alibaba Cloud | The underlying cloud platform providing compute, storage, and AI infrastructure. | DashScope API for all Qwen model calls |
| Qwen Cloud / Model Studio | The platform name for accessing Qwen models through Alibaba Cloud Model Studio (DashScope). | Same integration: DASHSCOPE_API_KEY → *.aliyuncs.com endpoints |
Eidetic-Plus is a Qwen-native memory agent built on Alibaba Cloud Model Studio (DashScope). Every intelligent operation in the system — including embeddings, extraction, verification, retrieval, reranking, generation, and evaluation — uses Qwen-family models through the official DashScope SDK.
Unlike systems that rely on fragmented model providers, Eidetic uses a unified Qwen intelligence layer through Alibaba Cloud DashScope. This provides consistent reasoning, verification, and generation throughout the entire memory lifecycle.
Qwen Model Stack
Each cognitive function is mapped to a specialized Qwen model:
| Function | Qwen Model |
|---|---|
| Text embeddings | text-embedding-v4 |
| Multimodal embeddings | tongyi-embedding-vision-plus |
| Memory importance scoring | qwen-flash |
| Fact extraction and consolidation | qwen-plus |
| Claim verification | qwen-plus |
| Retrieval reranking | qwen3-rerank |
| Final answer generation | qwen3-max |
| Vision, OCR, video, and document understanding | qwen-vl-plus, qwen-vl-ocr, qwen-long, qwen3-asr-flash |
Eidetic separates memory truth from intelligence:
Immutable Memory Layer → Qwen Cognitive Layer → Verified Answer
Qwen does not replace the memory substrate. Instead, it operates above an immutable foundation where every response must be grounded in stored evidence.
Alibaba Cloud Architecture
All model inference runs through Alibaba Cloud Model Studio (DashScope):
Eidetic Agent → DashScope API → Qwen Models → Verified Memory Response
The integration is centralized through:
eidetic/dashscope_client.py
eidetic/config.py
A missing DASHSCOPE_API_KEY fails explicitly. No model calls are mocked, and the default product stack uses only Qwen models hosted on Alibaba Cloud.
Fair Benchmark Evaluation
To ensure memory systems are compared fairly, all evaluated systems use the same Qwen-powered reader and judge:
Memory System → Qwen Reader → Qwen Judge → Score
Eidetic, Mem0, RAG, and Graphiti all answer through the same fixed reader (qwen-plus) and are evaluated using the same fixed judge (qwen3-max).
This ensures the benchmark measures memory architecture quality rather than differences between language models.
Each benchmark run records:
{
"reader_backend": "dashscope",
"judge_backend": "dashscope",
"judge_model": "qwen3-max"
}
What it does
Eidetic-Plus is a memory agent with metabolism: a system that stores experience permanently, retrieves across long time horizons without recency bias, and verifies every answer before responding.
Most AI memory systems treat retrieval as the memory itself. Eidetic separates these concepts. The underlying memory is immutable, while the retrieval layer can evolve, consolidate, and forget without changing the original truth.
Core capabilities:
- Lossless capture: Every memory is stored once in a content-addressed substrate using SHA-256. Nothing is deleted or overwritten.
- Graceful forgetting: FSRS-style decay only changes retrieval priority. Raw memory remains untouched and can be restored instantly.
- Age-independent recall: Older memories remain accessible with the same reliability as newer memories.
- Verified answers: Every response follows retrieval → generation → verification. Claims are checked against original records using NLI verification.
- Bi-temporal contradictions: Facts are invalidated through time instead of overwritten, preserving complete knowledge history.
Eidetic works as a universal memory layer through FastAPI and MCP. It provides tools such as remember, recall, consolidate, and prove_age_independence for MCP-compatible hosts.
The central principle:
The bottom never lies. Everything intelligent happens above the immutable memory layer.
How we built it
We modeled Eidetic after hippocampal indexing:
The index is not the content.
The system is divided into two layers.
Layer A: Immutable substrate
This is the source of truth. Every memory is permanently stored with its content address, ensuring the original record can always be recovered.
Layer B: Cognitive index
This layer contains the structures that make memory intelligent:
- Vector embeddings
- Knowledge graphs
- FSRS states
- Salience scores
- Retrieval relationships
Separating these layers allows Eidetic to forget, consolidate, and reorganize while guaranteeing that the underlying truth never changes.
The system is built from seven major components:
- Content-addressed substrate — SHA-256 storage guaranteeing immutable memory records.
- Hippocampal index — HNSW vector search combined with bi-temporal knowledge graphs and Personalized PageRank.
- Cognitive structure encoding — Metadata representation designed without age-based bias.
- Write-time salience gate — Bayesian surprise and Qwen importance scoring to determine memory priority.
- Consolidation engine — Offline replay and FSRS forgetting that modify only retrieval behavior.
- Hybrid retrieval pipeline — ANN, BM25, PPR, reciprocal rank fusion, reranking, and Qwen verification.
- Provenance engine — Source tracking and contradiction handling through bi-temporal invalidation.
Our stack includes:
- Python
- FastAPI
- FastMCP
- Qwen / DashScope
- hnswlib
- NetworkX
- SQLite
Production deployment maps directly to Alibaba Cloud infrastructure:
- OSS-WORM immutable storage
- AnalyticDB vector search
- Graph Database knowledge relationships
- Function Compute consolidation jobs
Challenges we ran into
The biggest challenge was making forgetting honest.
Human memory becomes less detailed over time, but AI systems cannot be allowed to rewrite reality. We solved this by separating storage from retrieval behavior. FSRS and salience influence ranking, but never modify the original memory.
Verification was another challenge. Running expensive verification on every response can be inefficient, so we built a structured claim pathway that allows lightweight answers to be verified quickly while reserving deeper verification for difficult cases.
Benchmark integrity was also critical. We prevented leakage and accidental tuning through:
- Rotating untouched holdout windows
- Leakage audits
- Published benchmark configurations
- Reproducible experiment manifests
Accomplishments that we're proud of
Eidetic achieved 277 verified answers compared to Mem0's 0 across eight disjoint holdout windows (n=320).
Additional results:
+42 rolling margin over Mem0
- Eidetic: 182/320
- Mem0: 140/320
Flat recall-vs-age curve
- Older memories perform equally to newer memories.
272/272 byte-identical substrate
- Forgetting never damaged stored information.
~83 median query tokens on the dev split with verification enabled
- Holdout evaluation measures verified response cost, including verification and write-side processing.
- Efficiency comes from structured retrieval, selective verification, and Qwen-powered reasoning.
1,200+ passing tests
- Zero production mocks.
- Fully reproducible benchmark pipeline.
What we learned
AI hallucination is often an architecture problem, not an unavoidable model limitation.
By separating immutable storage from mutable retrieval and verifying responses against original evidence, AI memory systems can abstain instead of guessing.
We also learned that recency bias is not required. Important memories should not become inaccessible simply because they are old.
The engineering principle stayed simple:
Layer A never lies.
What's next for Eidetic
We are expanding structured claim coverage to improve difficult retrieval cases and reduce verification cost.
Next improvements include:
- Token-free replay
- Link prediction
- Multi-resolution memory summaries
- Intelligent prefetching
Future evaluations will focus on LongMemEval and LoCoMo.
For deployment, Eidetic is expanding toward:
- OSS-WORM immutable storage
- AnalyticDB vector search
- Function Compute consolidation
- Large-scale multimodal memory pipelines
Long term, we are building memory infrastructure for agent teams: tracking problems, hypotheses, evidence, and decisions with time-aware replay for debugging complex multi-agent workflows.
Log in or sign up for Devpost to join the conversation.