NEWOne context engine for text, images & code — early access

Self-Recursive Context Engine
for your enterprise.

Context Engine Platform

Your teams are shipping more AI agents than ever — on the same models as everyone else. RCE is the self-recursive memory layer underneath them: one context graph spanning text, images, and code, with semantic recall and grounded answers — so every agent keeps context across sessions and returns work you can trust.

Get started Book a demo

Early access · Self-host or fully managed · Bring your own model keys

THE PROBLEM

Why agents fail without memory.

Same model, no memory — and complex tasks fall apart.

COLD START

Context vanishes between sessions; every run starts blind.

FLAT RETRIEVAL

Vector RAG returns lookalike chunks, not connected knowledge.

CONTEXT OVERFLOW

Stuff everything in the window and quality collapses.

NO PROACTIVITY

Memory only answers when asked; it never anticipates.

INSIDE THE ENGINE

A memory system, end to end.

Every modality, at enterprise scale, on a recursive knowledge graph.

MULTIMODAL MEMORY

One memory. Every modality.

Enterprise knowledge doesn't live in one format — and neither does RCE's memory. Every modality lands in a single context graph, governed and recalled the same way.

Text & images — documents, conversations, tickets and screenshots. Live today.
Code — repositories, symbols, call-graphs and diffs. Rolling out now.
One graph, one recall path, one governance model across them all.

Fig · One memory, every modalityIllustrative

Text & imagesLive

docs · chat · tickets · screenshots

CodeComing soon

repos · symbols · call-graphs · diffs

One context graph

entities · relations · dual embeddings

Same recall, grounding & governance — across every modality.

ENTERPRISE-SCALE MEMORY

Millions of context graphs, governed as one.

Per user, per org, per agent, per domain, per repo — every subject gets its own context graph, served and governed as a single system.

Isolated graphs for users, orgs, agents, domains & code
Access control, retention, provenance & audit at the substrate
Recall stays fast as graphs grow into the millions

CONTEXT ENGINE1,402,891 active graphsIllustrative

USERuser_8a32e1f92471,204now

ORGacme_co8941214s

AGENTagent_voyager1,8209,330now

DOMAINdomain_billing642185m

REPOpayments-svc5123,4011m

USERuser_d72b40c11867311m

Access controlRetentionProvenanceAudit

MEMORY SYSTEM

More than retrieval. A memory system.

RCE isn't a cache — it's a layered memory architecture that remembers, consolidates, and forgets.

Episodic, semantic & procedural memory
Short-term buffer → consolidated long-term
Pruning, consolidation & personalization built in

Fig 5 · Memory layersIllustrative

Short-termworking buffer · relevance + LRU

Episodicsessions as graph subgraphs

Semanticdurable facts + links

Proceduralreusable skills + workflows

Long-termconsolidated, versioned

↑ consolidaterecall ↓

RECURSIVE KNOWLEDGE GRAPH

Connected knowledge, not lookalike chunks.

RCE extracts entities and relations, then embeds them twice — text and structure.

Text embeddings capture meaning
GCN-augmented structural embeddings capture connection
Retrieves connected knowledge, not just lookalikes

Fig 4 · Recursive knowledge graphIllustrative

HOW IT WORKS

Ingest. Graph. Recall. Ground. Consolidate.

One loop turns raw context into durable, grounded memory.

Hierarchical chunking + LLM entity/relation extraction
Hybrid recall, federated across knowledge graphs
Answers grounded and validated against sources

Fig 6 · The loopIllustrative

Ingest

Graph

Recall

Ground

Consolidate

Documents → recursive KG + dual embeddings → hybrid recall → grounded answer → consolidate & prune. Then it loops.

SEMANTIC RECALL

Grounding, not keyword guessing.

RCE maps a knowledge graph of everything your agents see, then pulls only what's relevant — by graph relation, semantic similarity, and keyword.

Connected knowledge, not lookalike chunks
Hybrid graph + semantic + keyword retrieval
Every source ranked by relevance

Fig 2 · Semantic recallIllustrative

understood:JWTAPI keysmiddlewaresecurity

coverage 7 of 86 sources· 2 graph · 5 semanticcontext 2.1k / 32k tokens

› app/core/auth/security.py94%graph

› api/middleware/trace.py89%semantic

› app/core/auth/api_keys.py87%graph

› docs/auth.md71%semantic

· services/billing.service.py

· utils/stripe_client.py

· app/models/invoice.py

· api/payments.py

· services/payment.service.py

· webhooks/stripe.py

· app/core/ledger.py

· config/database.py

CURATION

Only what matters, in budget.

RCE doesn't dump your whole knowledge base into the prompt. It:

Retrieves only what the request needs
Compresses context without losing critical detail
Ranks and prioritizes by relevance
Stays within the token budget

Result: the infinite context window — think about shipping, not tokens.

Fig 1.1 · Raw context → curated contextIllustrative

5,210

Raw candidates

3,910

Graph relations

Grounded sources

Retrieve only what matters. Compress. Rank. Stay in budget.

2.1k / 32k tokens

PROACTIVE

It surfaces context before you ask.

Flat RAG waits for a query. RCE anticipates — enriching episodes and rolling forward the context an agent will need next.

Anticipates the next step
Enriches episodic memory continuously
Less round-tripping, faster answers

Fig 7 · Reactive vs proactiveIllustrative

Flat RAGreacts to the query

RCEsurfaces context ahead

The line marks the query. RCE has already surfaced the context — flat RAG is still catching up.

DURABILITY

Quality that holds as context grows.

Flat retrieval collapses when the window fills. RCE consolidates and prunes, so answers stay sharp across long sessions.

Consolidates memory over time
Prunes stale and duplicate facts
Surfaces context before you ask

Fig 3 · Answer quality over context lengthIllustrative

— RCE— flat retrieval / naive long-context

Activity

Recalling

Grounding answer

Consolidating

Re-explaining context

Context limit reached

Start new session

PROOF

Context quality determines answer quality.

Same models — better context wins. On LoCoMo, RCE projects on par with the strongest memory systems, approaching full-context quality at a fraction of the tokens.

On par with the best memory systems
≈ full-context quality, ~76% fewer tokens
Leads on long-horizon recall (LongMemEval)

Note: pre-release projections, benchmarked against published Mem0 / Zep baselines.

Fig 1 · LoCoMo — overall (LLM-judge)Projected · pre-release

Full-context72.9

RCE*68.3

Mem0ᵍ68.44

Mem066.88

Zep65.99

≈ full-context quality · ~76% fewer tokens (RCE ~2.1k vs ~17k)

LongMemEval (projected): RCE 74.6%* · Zep 71.2% · full-context 60.2%

* RCE figures are pre-release projections, not measured results. Baselines (Mem0, Zep) are published LoCoMo results. A full benchmark run is pending.

COMPARISON

RCE vs the alternatives.

What each approach can actually do.

Capability	RCE	Flat RAG	Full-context	Memory systems
Persistent cross-session memory	✓	✗	✗	✓
Knowledge graph (relations)	✓	✗	✗	◐
Hybrid retrieval (graph + semantic + keyword)	✓	◐	✗	◐
Proactive surfacing	✓	✗	✗	✗
Consolidation + forgetting	✓	✗	✗	◐
Grounded / validated answers	✓	◐	◐	◐
Multi-tenant + self-host	✓	◐	◐	◐
Token-efficient context	✓	◐	✗	◐

Capability comparison of approaches, not a benchmark. ✓ supported · ◐ partial / varies · ✗ not supported.

EVERY SURFACE

Drop it into any runtime.

MCP server · Python SDK · REST API · LangChain & CAMEL adapters.

MCP server
Python SDK
REST API
LangChain & CAMEL adapters

# install
pip install recursive-context-engine

# ingest a corpus into memory
rce ingest ./docs --store memory

# recall, grounded
rce recall "how does auth work?"

TRUST & GOVERNANCE

Enterprise memory you can govern.

Every fact is controlled, traceable, and isolated by tenant — by default.

PrincipalResourceAction

Policy

AllowDeny

Governed at the substrate

Authorization, retention, and audit live in the substrate — not bolted on. Policy applies across every graph, every query, every modality.

Robbie strongly favors Adidas.

CHATuser_8a32e1f92024-09-07

“I only wear Adidas. I love them.”

Provenance preserving

Every fact in the graph traces back to the source episode that produced it. Audit any answer back to exactly where it came from.

org_acme

org_initech

org_globex

Tenant-isolated

Each org, user, and agent gets its own isolated context graph. No bleed across tenants — memory stays private to whom it belongs.

ENTERPRISE

Built for the enterprise from day one.

Your context is your most sensitive asset. RCE keeps it yours.

MULTI-TENANT ISOLATION

Namespaced memory per tenant, with quotas.

API-KEY AUTH

Scoped sk_live_ keys, per-project access.

OTEL-NATIVE OBSERVABILITY

OpenTelemetry traces and Prometheus metrics.

SELF-HOST / AIR-GAPPABLE

Runs in your own VPC via Docker Compose.

USAGE & COST CONTROLS

Per-tenant usage tracking and analytics.

ORG CONFIG

Centralized KG registry and domain configuration.

EARLY ACCESSJoin the waitlist →

Self-Recursive Context Enginefor your enterprise.