📊 QFM vs Linear Memory: 28× Faster Knowledge Retrieval

Why We Benchmarked QFM

Most AI memory systems make performance claims without data.

"Our vector database is fast." "Our RAG system scales." "Our memory architecture is efficient."

But where are the numbers?

When we built Quantum Fractal Memory (QFM), we wanted to prove it was faster — not just claim it. So we built both systems (QFM and linear memory) and measured them head-to-head.

This post presents the full results.

Methodology: 500 Nodes, 200 Edges, 100 Iterations

We designed a benchmark that tests the core use cases of agent memory:

• Identity recall — "Who am I? What are my constraints?"
• Knowledge retrieval — "What do I know about X?"
• Contextual queries — "What's relevant right now?"
• Associative search — "Show me everything related to Y"

Test Environment

• Systems tested: QFM (fractal memory) vs Linear Memory (flat list with keyword matching)
• Dataset: 500 synthetic nodes, 200 typed edges
• Levels: L0 (Identity, 50 nodes), L1 (Knowledge, 200 nodes), L2 (Episodes, 150 nodes), L3 (Context, 100 nodes)
• Iterations: 100 queries per test
• Language: Python 3.11, stdlib only (no external dependencies)
• Hardware: Standard VPS (4 vCPU, 8GB RAM)
• Seed: Deterministic random seed for reproducibility

Why Linear Memory as the Baseline?

We chose linear memory (flat list with keyword matching) as the baseline for three reasons:

1. Most common approach — Many AI agents today use markdown files or simple lists
2. Simple to understand — Easy to verify and reproduce
3. Conservative baseline — We wanted to prove QFM's advantage against even the simplest system

Results Table: All 7 Tests

Here are the complete results from all seven benchmark tests:

What The Numbers Mean

The raw numbers tell the story: QFM is consistently faster. But why?

Fractal Descent vs Linear Scan

Linear memory works like this:

• Query: "Find knowledge about SQL injection"
• Linear scans all 500 nodes, checking each one for keyword match
• Time complexity: O(n) — performance degrades linearly as memory grows

QFM works like this:

• Query: "Find knowledge about SQL injection"
• QFM descends directly to L1 (Knowledge layer) — only 200 nodes to search
• Within L1, it uses fractal structure to narrow the search space
• Time complexity: O(log n) — performance stays fast even as memory grows

Test-by-Test Breakdown

Test 1: Identity Recall (11× faster)
Identity nodes (L0) are small and critical. QFM keeps them at the top of the hierarchy, so retrieval is nearly instant. Linear memory has to scan everything.

Test 2: Knowledge Retrieval (28× faster)
This is the biggest win. Knowledge nodes (L1) are the most queried, and QFM's level-aware indexing means we only search L1 — not L0, L2, or L3.

Test 3: Episode Search (7.5× faster)
Episodes (L2) are larger and more complex, but fractal descent still outperforms linear scan.

Test 4: Context Query (7.6× faster)
Context (L3) is session-specific. QFM isolates it from other levels, so queries are fast.

Test 5: Cross-Level Association (+35 nodes)
This is the magic. Linear found 12 nodes matching "trust." QFM found those plus 35 additional nodes via edge traversal — related concepts across all four levels.

Test 6: Scale Test (37× faster at 5000 nodes)
The speedup increases as memory grows. At 5000 nodes, linear memory becomes unusable (142ms per query). QFM stays fast (3.8ms).

Test 7: Identity Preservation Under Load (2.3× faster)
Even under heavy query load, QFM maintains faster identity recall. This matters for security — agents should always know "who am I?" instantly.

The Edge Effect: 35 Additional Related Nodes

Test #5 is the most important result — and the one that proves QFM isn't just faster, it's smarter.

We queried both systems: "Find everything related to trust."

Linear memory returned 12 nodes — those containing the keyword "trust."

QFM returned 47 nodes — the keyword matches plus 35 additional nodes connected via typed edges:

• Semantic edges — "Trust" is related to "verification," "authentication," "honesty"
• Temporal edges — "Trust score increased after successful audit"
• Causal edges — "Low trust caused request refusal"
• Hierarchical edges — "Trust" defined in L0 identity, applied in L2 episodes

Scale Analysis: 100 to 5000 Nodes

We ran Test #2 (Knowledge Retrieval) at five different scales:

Key insight: QFM's advantage increases with scale. At 5000 nodes, linear memory is 37× slower. At 10,000 nodes, we'd expect 50-60× slower.

This is why fractal structure matters: the system stays fast as memory grows.

Limitations and Future Work

We designed this benchmark to be fair and transparent — which means acknowledging its limitations.

What This Benchmark Didn't Test

• Vector databases — We compared against linear memory (keyword matching), not embeddings-based search. Future benchmarks will include RAG/vector DB baselines.
• Write performance — This benchmark focused on retrieval speed. We didn't measure insertion, update, or deletion performance.
• Multi-agent systems — All tests were single-agent. We didn't benchmark cross-agent memory sharing or trust delegation.
• Real-world workloads — Synthetic data is clean and predictable. Real agent memory is messier — partial queries, typos, ambiguous context.

Future Benchmarks

We're working on:

• QFM vs RAG/Vector DBs — Comparing against more sophisticated baselines (Pinecone, Weaviate, Chroma)
• Write performance — Measuring insertion and update latency
• Memory under adversarial load — What happens when an attacker floods the system with garbage data?
• Multi-agent memory sharing — How fast can agents sync shared knowledge?

Download the Full White Paper

This post summarizes the key findings. The full white paper includes:

• Complete methodology and test harness design
• Raw data (CSV) for all 700 test runs
• Statistical analysis (mean, median, std dev, p-values)
• Fractal descent algorithm pseudocode
• Full source code (Python + JavaScript implementations)