Process sensitive data in a sealed ephemeral environment. Get a cryptographic proof it was destroyed. Verify it without trusting us.
Free tier · 100 sessions/month · No credit card
Process patient data for diagnostics or analytics — then prove to auditors every byte was destroyed. Replace compliance consultants with cryptographic proof.
Analyze privileged documents through AI tools without creating persistent copies. Attorney-client privilege requires proof of non-retention.
SOC 2 requires documenting data lifecycle management. Nanorix generates audit-ready destruction receipts automatically — no manual documentation.
Train models on licensed datasets where the license requires proof of deletion after use. Process the data, train the model, destroy the data, prove it.
You process sensitive data — patient records, legal documents, financial models. When you're done, you delete it. But "deleted" doesn't mean gone. And you can't prove otherwise.
Filesystem journals, swap space, kernel logs, and memory residues survive "deletion." Forensic tools reconstruct what you thought was gone.
You document data handling in spreadsheets. Auditors ask for proof of destruction. You produce screenshots and promises. Nobody is convinced.
VPNs, encrypted disks, access controls — all layered on top of systems designed to remember everything. The foundation fights the goal.
Nanorix replaces trust with cryptographic proof.
Every computation happens inside a cryptographically sealed session that self-destructs. No logs survive. No data persists. The proof is mathematical.
from nanorix import NanorixClient client = NanorixClient(api_key="nanorix_sk_live_...") # 1. Create a sealed ephemeral session session = client.create_session(ttl_seconds=300) # 2. Process sensitive data inside the sandbox result = session.execute("analyze(patient_records)") # 3. Destroy everything — get your cryptographic proof cdp = session.destroy() # 4. Verify the proof — anyone can, no trust required assert client.verify(cdp).valid
Sealed sandbox
POST /v1/sessionsVolatile memory
POST /v1/sessions/{id}/exec12-step wipe
DELETE /v1/sessions/{id}Math proves it
POST /v1/verifyYour data enters volatile memory. Results come out. Everything else is destroyed through a 12-step cryptographic sequence, signed with an ephemeral Ed25519 key — which is itself destroyed after signing. The proof is yours forever. The data is gone forever.
Add ~10 lines to your backend. Choose the pattern that matches your workflow.
Send data and computation to Nanorix. Your code runs inside our volatile sandbox. Only processed results come back. Raw data is destroyed with proof.
# Hospital sends patient data to your API patient_data = request.json["record"] # Forward directly into Nanorix — never store locally session = nanorix.create_session(ttl_seconds=300) result = session.execute( f"python model.py --data '{patient_data}'" ) # Only the diagnosis leaves the sandbox diagnosis = result.output # Raw PHI destroyed — proof generated cdp = session.destroy() cdp.save(f"proofs/{session.id}.json") # patient_data was never written to your disk, # your database, or your logs. return {"diagnosis": diagnosis}
Point your data source directly at Nanorix. Incoming records land in volatile memory, get processed, and only derived results reach your system.
# Webhook: hospital sends records directly @app.route("/intake", methods=["POST"]) def receive_patient_data(): raw = request.data # don't parse, don't store # Immediately forward into Nanorix session = nanorix.create_session(ttl_seconds=120) result = session.execute( "python classify.py", stdin=raw ) # Raw PHI destroyed with proof cdp = session.destroy() cdp.save(f"proofs/{session.id}.json") # Your DB stores the score, never the record db.insert(score=result.output, proof=cdp.root_hash) return {"score": result.output}
Historical data that needs to expire — retention policies, patient requests, regulatory purges. Send each batch through verified destruction. Get a CDP for your audit trail.
# Monthly: destroy expired patient records expired = db.query( "SELECT * FROM patients WHERE expires < NOW()" ) for batch in chunk(expired, size=100): session = nanorix.create_session(ttl_seconds=60) session.execute( f"echo '{json.dumps(batch)}' > /tmp/data" ) cdp = session.destroy() cdp.save(f"compliance/{cdp.cdp_id}.json") # Now safe to delete from your database db.execute("DELETE FROM patients WHERE id IN %s", [r.id for r in batch]) # Auditor: nanorix verify compliance/*.json
Some sessions start in 2026 and end in 2028. A lightweight Nanorix agent runs on your infrastructure — your GPUs, your storage, your schedule. When the retention policy expires or you decide to destroy, the agent runs the full 12-step destruction chain locally and generates a CDP.
# Install the Nanorix agent $ curl -sSL https://install.nanorix.io | sh # Configure with your API key $ nanorix-agent init --api-key nanorix_sk_live_... # Set a retention policy — destroy after 90 days $ nanorix-agent watch /data/patients/ --destroy-after 90d # Or destroy on demand — any time you're ready $ nanorix-agent destroy /data/case-2024/ --generate-cdp ✓ 12-step destruction chain complete ⬡ CDP saved: proofs/cdp_a8f3e71c.json Verify: nanorix verify proofs/cdp_a8f3e71c.json
Agent beta launching Q3 2026
1,000× to 2,500× cheaper — using the lowest manual certificate cost ($50). Most enterprises pay $150–$500, making the real savings 3,000× to 25,000×.
{
"version": "2.0",
"session_id": "sess_a8f3e71c...",
"terminated_at": "2026-02-27T14:30:00Z",
"proof_chain": {
"steps": [
{ "step": 0, "subsystem": "eee_namespace",
"hash": "7d4f8a91b3c7e2..." },
// ... 10 more steps, each hash-chained
{ "step": 11, "subsystem": "session_state",
"hash": "2c8a4f63d19e..." }
],
"proof_hash": "2c8a4f63d19e..."
},
"root_hash": "91d7e580a4b2...",
"attestation": {
"algorithm": "Ed25519",
"signature": "VGhpcyBpcyBhIG...",
"public_key": "MCowBQYDK2Vw...",
"key_destroyed": true
}
}Each step hash-chains to the previous. Tamper with one step and the entire chain breaks.
Binds destruction chain, session ID, and timestamp into a single verifiable hash.
Ephemeral key signs the root hash, then destroys itself. Mathematically bound to the destruction event.
The signing key is zeroized immediately after use. One key, one proof, forever.
The CDP is the trust anchor — not our database. Store it. Verify it in 5 years. No dependency on us.
from nanorix.verify import verify_cdp_offline import json with open("destruction_proof.json") as f: cdp = json.load(f) result = verify_cdp_offline(cdp) print(result) # ✅ Chain valid · Signature valid · Root hash valid
The verification algorithm is public. The Python SDK is open source. Your auditor can run this themselves.
Full CDP specification →
Steps 0–2 destroy your data. Steps 3–11 destroy every trace the system held about it.
After step 2, your data no longer exists in any form.
System state can reveal information about the data it processed. We destroy that too.
Every tier includes signed CDPs, public verification, offline verifiability, Python SDK, and CLI verifier.
Each CDP replaces a $50–$500 manual destruction certificate. That's 1,000× cheaper.
All plans scale. Overages billed at tier rate. No hidden fees. Cancel anytime.Deletion marks space as available — it doesn't erase data. Filesystem journals, swap space, kernel logs, and memory residues all retain fragments. Nanorix never writes to persistent storage. Data exists only in volatile memory and is cryptographically shredded at termination. The destruction proof verifies this mathematically.
A 12-step hash-chained receipt covering every destruction component: namespace teardown, tmpfs unmount, multi-pass memory overwrite, key zeroization, identity destruction, and zero-state verification. Each step is independently verified and hash-chained so tampering is detectable. Signed with an ephemeral Ed25519 key that's destroyed after signing.
Nanorix provides what auditors actually want: verifiable proof that sensitive data was destroyed after processing. The destruction receipt is a cryptographic artifact — not a screenshot, not a policy document, not a promise. It's mathematical evidence with an independently verifiable hash chain and Ed25519 signature.
Phase 1 is a cloud API for workloads that fit inside ephemeral sessions (up to 2 hours). For GPU-heavy workloads or long-lived data, our roadmap includes an embeddable agent that runs on your infrastructure — your GPUs, your storage, your timeline. When you're ready to destroy, the agent handles verified destruction and generates CDPs locally. Same proof, your hardware.
Yes. The verification algorithm, CDP specification, Python SDK verify_cdp_offline() function, and CLI verifier are all open. Security researchers and your auditors can independently verify destruction proofs without trusting our infrastructure. The core engine is patent-pending.
Session creation takes milliseconds. Execution runs at native speed inside Linux namespaces — no virtualization overhead. Destruction adds a small overhead for multi-pass memory wiping and proof generation, but the entire lifecycle completes in under a second for typical workloads.
Get your API key instantly. Install the SDK. Add ~10 lines to your backend.
Key shown once. Save it immediately.
We'll walk you through architecture, compliance mapping, and a proof-of-concept.
Schedule a Call →Typically responds within 4 hours.
Cryptographic destruction proofs are the beginning. The Nanorix architecture covers ephemeral execution, disposable identity rotation, sealed application isolation, zero-knowledge networking, and adaptive privacy governance. We're building the infrastructure layer for identity-free computing.