X-LMP Protocol  ·  Exergy Vault  ·  Edge-Native

The Sovereign
Memory Layer
for AI.

Edge-distributed object storage with Zero-Knowledge compute at rest. Query exabytes in milliseconds. Pay zero egress fees. S3-compatible from day one.

Get API Keys — Free Read the Docs
$0.004
per GB stored
$0.00
egress fees
<1ms
ZK query
512KB
shard size
< 1 MILLISECOND
<1ms Zero-Knowledge Query Latency

The X-LMP engine executes directly inside the storage layer. No data movement. No round-trips. Every answer sealed with a Groth16 cryptographic receipt.

Query In Place
Groth16 Receipts
512KB Shard Size
Zero Egress
S3-Compatible
The Problem

"Stop paying to move
your own data."

Legacy clouds bill you twice — to store, and again every time you read. Exergy Vault inverts the model. The query travels to the data. The data never moves.

Legacy Cloud

Download → Process → Pay Again

Pull your 100 GB dataset to your inference server every time your AI needs a query. Pay $0.09/GB in egress. Repeat every cycle. Watch your bill compound and your latency spike.

Exergy Vault

Query-In-Place. Zero Movement.

Send a 1 KB intent to the X-LMP engine. It executes Zero-Knowledge compute directly on sharded data at rest. Receive a 1 KB answer sealed with a Groth16 proof. Zero data moved. Zero egress billed.

Core Features

X-LMP Mechanics,
Built for Builders.

S3-Compatible Drop-In

No new libraries. Change your endpoint URL and API key. Integrates into your existing Node.js, Python, or Go stack in three lines of code.

Zero-Knowledge Query Engine

Don't load massive datasets into your LLM context. Upload to the Vault, send a search intent — the X-LMP engine runs at rest and returns only the exact answer.

Cryptographic Sharding

Data hits the API and is shattered into 512 KB encrypted shards distributed across the edge network. Your system stores a 32-byte Merkle root. Nothing else.

Infinite AI Context Windows

Give your agents unlimited memory without token limits. Compress entire conversation histories into Hollow Objects. Re-expand any subset with a ZK query — no VRAM burned.

Sub-Millisecond Edge Queries

Queries execute on the edge node closest to the data. No round-trip to a central datacenter. Groth16 seals every result — verifiable by your backend independently.

Auditable ZK Receipts

Every query result ships with a cryptographic proof that the answer was computed correctly against the shard set — without ever exposing the underlying data. Sovereign by design.

Pricing

Built to leave AWS S3
and Pinecone behind.

AWS S3 Standard
$0.023 / GB
+ $0.09/GB egress on every read
Standard object storage
Centralized data centers
No built-in AI query engine
Egress billed on every read
No cryptographic proof layer
Pinecone Vector DB
$70 / mo min
Serverless: $0.096/hr pod cost
Vector similarity only
No raw object storage
Managed cloud lock-in
No ZK receipts
High base cost before first query
EXERGY VAULT
Exergy Vault (API & UI)
$0.004 / GB
Zero egress. Zero base cost.
Edge-distributed sharding
ZK Query-In-Place (X-LMP)
Cryptographic Hollow Objects
S3-compatible SDK
Groth16 receipt on every query
Developer Experience

A clean, familiar REST API.

Exergy Vault is a drop-in for any S3-compatible client. Three lines to integrate. Zero configuration. First 10 GB free, no card required.

1
Upload — Push context to the Vault. $0.004/GB stored. Zero egress ever.
2
Query — Send a natural language intent. X-LMP runs inside the storage layer.
3
Verify — Receive a ZK-sealed answer with a Groth16 cryptographic receipt.
# Step 1 — Upload your data (multipart)
curl -X POST https://portal.exergynet.org/api/xlmp/ingest \
  -H "Authorization: Bearer $EXERGYNET_API_KEY" \
  -F "file=@./my_dataset.json"

# → { "xlmp_root": "0x4a2f...", "shard_count": 4, "total_bytes": 2048000 }

# Step 2 — Query at rest (ZK, no data movement)
curl -X POST https://portal.exergynet.org/api/xlmp/query \
  -H "Authorization: Bearer $EXERGYNET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"xlmp_root":"0x4a2f...","query_params":{"intent":"Patient resting heart rate?"}}'

# → { "journal": { "result": "65 BPM", "confidence": 0.97, "zk_sealed": true } }
// Step 1 — Upload your data
const form = new FormData();
form.append('file', fileBlob, 'dataset.json');

const { xlmp_root } = await fetch(
  'https://portal.exergynet.org/api/xlmp/ingest',
  { method: 'POST', headers: { 'Authorization': `Bearer ${API_KEY}` }, body: form }
).then(r => r.json());

// Step 2 — ZK query at rest
const { journal } = await fetch(
  'https://portal.exergynet.org/api/xlmp/query',
  { method: 'POST',
    headers: { 'Authorization': `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
    body: JSON.stringify({ xlmp_root, query_params: { intent: 'Patient resting heart rate?' } })
  }
).then(r => r.json());

console.log(journal.result);        // "65 BPM"
console.log(journal.confidence);    // 0.97
console.log(journal.zk_sealed);     // true
import requests

# Step 1 — Upload your data
with open("dataset.json", "rb") as f:
    ingest = requests.post(
        "https://portal.exergynet.org/api/xlmp/ingest",
        headers={"Authorization": f"Bearer {API_KEY}"},
        files={"file": ("dataset.json", f, "application/json")},
    )
xlmp_root = ingest.json()["xlmp_root"]

# Step 2 — ZK query at rest
res = requests.post(
    "https://portal.exergynet.org/api/xlmp/query",
    headers={"Authorization": f"Bearer {API_KEY}"},
    json={"xlmp_root": xlmp_root,
          "query_params": {"intent": "Patient resting heart rate?"}},
)
journal = res.json()["journal"]
print(journal["result"])      # 65 BPM
print(journal["confidence"])  # 0.97
print(journal["zk_sealed"])   # True
View Full API Reference ↓
API Reference

Two endpoints.
Infinite memory.

The Exergy Vault REST API is stateless, JSON-native, and authenticated with a bearer token. Get your key at portal.exergynet.org/dashboard/keys.

POST portal.exergynet.org/api/xlmp/ingest

Upload any file. The X-LMP engine shatters it into 512 KB encrypted shards and returns a 32-byte Merkle root — your permanent Hollow Object handle.

Request — multipart/form-data
FieldTypeRequiredDescription
filebinaryrequiredAny file: JSON, PDF, CSV, TXT, audio, etc. Max 500 MB.
Response — 200 OK
FieldTypeDescription
xlmp_rootstring0x-prefixed 32-byte Merkle root. Your Hollow Object handle.
shard_countnumberNumber of 512 KB shards created.
total_bytesnumberTotal size of file stored.
created_atstringISO 8601 timestamp.
 
curl -X POST \
  https://portal.exergynet.org/api/xlmp/ingest \
  -H "Authorization: Bearer $EXERGYNET_API_KEY" \
  -F "file=@./dataset.json"
const form = new FormData();
form.append('file', blob, 'dataset.json');
const res = await fetch(
  'https://portal.exergynet.org/api/xlmp/ingest',
  { method:'POST',
    headers:{'Authorization':`Bearer ${API_KEY}`},
    body: form }
);
const { xlmp_root } = await res.json();
import requests
with open("dataset.json","rb") as f:
    r = requests.post(
      "https://portal.exergynet.org/api/xlmp/ingest",
      headers={"Authorization": f"Bearer {API_KEY}"},
      files={"file":("dataset.json",f,"application/json")},
    )
xlmp_root = r.json()["xlmp_root"]
POST portal.exergynet.org/api/xlmp/query

Execute a Zero-Knowledge query against a Hollow Object. The query travels to the shards — no data is moved. Returns a ZK-sealed answer with a Groth16 cryptographic receipt.

Request — application/json
FieldTypeRequiredDescription
xlmp_rootstringrequiredHollow Object handle from ingest.
query_params.intentstringrequiredNatural language or structured query.
image_idstringoptionalCondenser circuit ID. Defaults to Exergy Condenser.
Response — 200 OK
FieldTypeDescription
journal.resultstringZK-sealed answer to your query.
journal.confidencenumberExtraction confidence [0.0–1.0].
journal.citationsarrayShard references used in computation.
journal.groth16_receiptstringOn-chain-verifiable proof of correct execution.
latency_msnumberZK proof generation time in milliseconds.
proof_size_bytesnumberSize of the Groth16 proof payload.
 
curl -X POST \
  https://portal.exergynet.org/api/xlmp/query \
  -H "Authorization: Bearer $EXERGYNET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "xlmp_root": "0x4a2f...",
    "query_params": {
      "intent": "Patient resting heart rate?"
    }
  }'
const { journal, latency_ms } = await fetch(
  'https://portal.exergynet.org/api/xlmp/query',
  { method:'POST',
    headers:{
      'Authorization':`Bearer ${API_KEY}`,
      'Content-Type':'application/json'
    },
    body: JSON.stringify({
      xlmp_root,
      query_params:{ intent:'Patient resting heart rate?' }
    })
  }
).then(r => r.json());

console.log(journal.result);          // "65 BPM"
console.log(journal.groth16_receipt); // 0xb226...
import requests
res = requests.post(
  "https://portal.exergynet.org/api/xlmp/query",
  headers={"Authorization": f"Bearer {API_KEY}"},
  json={
    "xlmp_root": xlmp_root,
    "query_params": {"intent": "Patient resting heart rate?"}
  },
)
j = res.json()["journal"]
print(j["result"])           # 65 BPM
print(j["groth16_receipt"])  # 0xb226...
Live API Demo — No login required

Try a ZK query right now.

This hits a real public endpoint against a synthetic medical record dataset. Ask it anything about the patient — heart rate, medications, lab results, appointments.

What is the heart rate? Current medications? Blood pressure reading? Latest HbA1c result? Any allergies? Last visit date? Cholesterol level? Patient diagnoses?
200 OK
⬡ Querying synthetic-medical-record.json · 1 shard · Groth16 sealed Get API Keys — Query Your Own Data →

Full interactive docs with copy-ready examples

Your API key, all 7 ExergyNet services, live endpoints, cURL · TypeScript · Python — all in one place.

View Full API Docs at portal.exergynet.org →
Use Cases

Built for the AI Era.

From AI agent developers to enterprise backends and Web3 protocols — one sovereign memory layer replaces fragile, expensive infrastructure.

AI Agents

Infinite Context Windows

Give your agents unlimited memory without hitting token limits. Compress entire conversation histories into a Hollow Object. Re-expand any subset on demand — no VRAM, no egress, no bill shock.

Enterprise

Sovereign Document Search

Store massive PDF, CSV, and medical record archives securely. Search them instantly via natural language. HIPAA-compatible — ZK receipts on every query, data never exposed or moved.

Web3 / DePIN

Verifiable Edge Storage

Cryptographically verifiable storage without fragile IPFS pinning. Every shard is content-addressed. Every query produces an on-chain-verifiable Groth16 proof — sovereign and auditable.

FAQ

Common Questions.

Exergy Vault is edge-distributed object storage with built-in Zero-Knowledge query execution. S3-compatible, $0.004/GB with zero egress, and allows AI agents to query compressed data without loading full datasets into memory.
$0.004 per GB stored — roughly 80% less than AWS S3 Standard. Zero egress fees and no base monthly cost. Your first 10 GB is free with no credit card required.
Yes. Drop-in replacement for any S3-compatible client. Change your endpoint URL and API key in your existing Node.js, Python, or Go client — no new SDKs, no migration tooling.
X-LMP (Exergy Latent Memory Protocol) is our proprietary Zero-Knowledge compute-at-rest engine. The query travels to the data — not the other way around. The answer is sealed with a Groth16 cryptographic proof your backend can independently verify.
Data is shattered into 512 KB encrypted shards distributed across the global edge network the moment it hits the API. Your system stores only a 32-byte cryptographic Merkle root. The original data is never reassembled in any single location.
Get Started

Integrate in under 5 minutes.

Your first 10 GB free. No credit card. S3-compatible from day one.

Get Free API Keys View API Docs →