Alpha — Rust-native — Local-first

Stop paying to re-reason
what your agents
already know.

Semantic Cache Engine intercepts repeated questions, serves deterministic answers from a shared reasoning layer, and routes new questions with provenance-rich context — cutting inference cost and keeping agent behavior consistent across your codebase and document workflows.

73–80% token reduction on warm queries
0 tokens on cache hits
0 egress by default
40 / 40 milestone tests passing

A server, not a plugin.

Semantic Cache Engine is a local-first server written in Rust. It exposes a REST and MCP interface and runs on your own hardware — on-prem, in a VPC, or on a developer workstation. There is no hosted service, no metered API, and no inference endpoint owned by us. Every query is resolved against a local store.

It is not a framework and not an agent. It is a substrate layer that any agent, any model, and any orchestration stack can call. The same server that answers a single developer's questions during a session can serve a fleet of 50 concurrent agents across an enterprise workflow without modification.

VS Code integration is available as an MCP client — but the server is the product.

Framework-agnostic
Any agent that can speak HTTP or MCP can use it directly, with SDK adapters for popular orchestrators and custom adapters available for enterprise stacks. The protocol is open — no vendor lock-in.
Model-agnostic
The cache layer sits beneath the model. Swap models freely — cached answers do not move.
IDE-agnostic
Any MCP-capable client works — VS Code, Cursor, JetBrains, Neovim, or a bare HTTP call from a script.
Zero egress by default
All reasoning cards, embeddings, and graph edges live in a local store. Nothing leaves your machine unless you explicitly export a bundle.
Savings compound
Every agent handoff that produces an answer commits it back to the store. The next agent asking an equivalent question pays zero. The ratio improves continuously.

Every agent call re-reasons from scratch.

In a modern agent workflow, multiple agents — sometimes dozens — are querying an LLM independently. Each one re-establishes the same foundational understanding of your documents, your rules, and your domain. None of them share what they learned. The token meter runs the same for agent number fifty as it did for agent number one.

At scale, this is the primary driver of inference cost in document-heavy workflows. Insurance underwriting. Legal document review. Regulatory compliance. Claims processing. Every run of the same logical question burns the same tokens, produces the same answer, and then discards it.

Without SCE
Agent 1 reasons through a policy clause — 4,200 tokens
Agent 2 asks the same clause — 4,200 tokens again
Agent 50 asks it — still 4,200 tokens
50 agents × 4,200 = 210,000 tokens
With SCE
Agent 1 reasons — 4,200 tokens invested, answer committed
Agents 2–50 recall — 0 tokens each
4,200 tokens total — 98% reduction

Ingest. Resolve. Commit. Repeat.

01

Ingest your documents

Point the server at your document sources. It chunks and indexes them into a local store. Every section becomes a retrievable reasoning anchor with provenance tracking.

02

Every question hits the cache first

When an agent sends a question, the resolver checks the local store through a multi-tier matching cascade. Exact matches, paraphrases, and semantically equivalent questions are all candidates for a warm recall — without calling the LLM.

03

Partial matches get structured context

Questions that are close but not confident enough for a direct recall are returned to the agent with a graph-hydrated context packet. The agent reasons with a structured starting point instead of a blank slate — fewer tokens in, same quality out.

04

New answers are committed back

When the agent produces an answer on a cache miss, it commits the result back to the store. Every future agent asking an equivalent question gets a zero-token recall. The store gets smarter on every handoff.

Recall
High-confidence match. Answer returned from local store. Zero tokens. No model call.
Graph-assisted
Near-match found. Agent receives the card plus related graph context — token cost reduced, reasoning quality preserved.
Agent handoff
No match, but a structural document map is available. Agent receives a guided anchor index instead of starting blind.
Generic
Cold miss — no local signal. Full agent call. Answer committed on return. Paid once; recalled free thereafter.
Markdown / MDX
.md  .markdown  .mdx
PDF
.pdf
DOCX
.docx
Plaintext
.txt
LaTeX
.tex  .latex
CSV / TSV
.csv  .tsv
Spreadsheets
.xlsx  .xls  .xlsm  .xlsb  .xltx
YAML / TOML / JSON
.yaml  .yml  .toml  .json
SQL
.sql
Source code
.rs  .py  .js  .jsx  .ts  .tsx  .go  .java  .cs  .c  .cpp  .h  .hpp  .rb  .swift  .kt  .scala
Shell / PowerShell
.sh  .ps1

What the test suite proves.

40 / 40
Milestone tests passing
Multi-domain retrieval, confusable-pair disambiguation, semantic delta detection, cross-document rule reuse, concurrent fleet simulation — all green.
0
Wrong-card recalls
Across 50 off-domain adversarial probes and 250 concurrent agent requests, no card was ever returned for the wrong question. Hard gate: zero tolerance.
73–80%
Token reduction, warm queries
Per-run savings of 73–77% on first warm pass; all-time ratio reaches ~80% as the card store matures. Verified with real LLM API calls, engine-on vs engine-off.
50
Concurrent agents, zero errors
50 agents × 5 questions = 250 simultaneous requests. ≥95% recall rate. Zero wrong-card recalls. Zero server errors. Concurrency correctness verified.
14 / 14
Acceptance patterns verified
Cascade invalidation, cross-document reasoning, multi-tenant isolation, tamper detection, concurrent writes, dependency edges — 12 pass outright, 2 are documented scope limitations. Zero unexplained failures.
10k
Cards, no degradation
10,000 cards committed with zero errors. Exact-match resolve stayed fast at that volume — P50 17ms, P95 22ms, P99 29ms — all comfortably under threshold. No reindexing required.
ROI is tracked per card. The server records how many tokens each unique reasoning task cost to produce, how many times it has been recalled, and the cumulative tokens saved. A live stats endpoint gives exact numbers — tokens invested, tokens saved, and agent calls avoided — at any point in time.

Built for workflows where reasoning has consequences.

Insurance
Policy ingestion, claims evaluation, eligibility checks. Agents reason through coverage rules once; every downstream agent recalls at zero cost. Delta detection re-indexes only what changed when policies are updated.
Legal
Contract review, amendment cascades, risk analysis. Cached reasoning cards carry the same clause interpretation across every document in a corpus without redundant re-analysis.
Regulatory
Statute interpretation, enforcement decisions, audit chains. Every committed card carries a cryptographic provenance fingerprint — tamper-evident and chain-of-custody ready without an external notarization service.
Multi-tenant namespace isolation — each team or department's cards are strictly separated
Cryptographic provenance on every committed card
Cascade invalidation — update a source, affected cards evicted automatically
Related context surfaces automatically with every partial match
Semantic delta detection — re-ingest only rewrites what actually changed
Per-card ROI metrics — tokens invested, tokens saved, recalls served

Four stages to enterprise-grade.

Stage 1 — Alpha
September 15, 2026 · testing engine core capabilities

Local reasoning substrate

The core reasoning engine itself — deterministic recall, provenance, dependency-graph cascade invalidation — proven out against a full acceptance test suite, then handed to real, independent developers for hands-on testing via the packaged VS Code extension.

Multi-tier recall Dependency graph Cascade invalidation Provenance fingerprints 40/40 tests
Stage 2 — Beta
October 2026 · gated by Stage 1 (Alpha) · full Rust server + agent workflow verification

Full server testing under real agent workflows

Full exercise of the Rust server itself — concurrent multi-agent fleets, multi-tenant isolation, explicit dependency-edge workflows between agents, and cascade invalidation under real load, not just single-session testing. Confirms the server holds up before any pilot commitment.

REST + MCP server Concurrent fleet load Multi-tenant isolation Agent dependency workflows Acceptance suite hardening
Stage 3 — Early Pilot
Target: November 2026 · gated by Stage 2 (Beta)

Production hardening + first-customer deployment

TLS, authentication, request-level audit logging, configurable retention, structured error handling, observability, and backup procedures. Deployed into one or two high-value enterprise workflows to produce real-world ROI evidence at scale.

TLS + Auth Audit logging Docker / on-prem Pilot integration Real-world ROI data
Stage 4 — Enterprise GA
Gated by Stage 3 (Pilot) success

Supported product with reference architectures

Versioned releases, schema migration tooling, SLAs, multi-tenant and VPC reference architectures, client SDKs, and enterprise onboarding. The substrate becomes a shared reasoning layer across departments — a single store serving every agent in an organization, with compliance-ready audit trails built in.

Client SDKs Reference architectures SLA + support Org-wide shared store Compliance audit trails

Be among the first teams in production.