What is Eclipseal?
Confidential AI compute for Robinhood Chain: run agents, private LLMs and GPU jobs inside hardware enclaves, and prove what ran.
Eclipseal runs AI workloads inside trusted execution environments (TEEs): confidential virtual machines whose memory is encrypted by the processor, with keys that never leave the chip. The host operating system, the hypervisor and the cloud operator all stay outside. The chip also signs a report of exactly what was loaded, so every run comes with a proof you can check yourself.
The problem
The approach
The proof
$ECLS is the project token. It launches on Pons, the launchpad on Robinhood Chain, and sets your tier in the console. Eclipseal is an independent project and is not affiliated with Robinhood Markets, Inc.
Devnet status: what is live and what is simulated
Eclipseal is in devnet. The cryptography and the verifier are real; the TEE hardware behind them is not connected yet.
Real today
Live on devnet- Attestation reports are canonical JSON signed with Ed25519. Change one byte and verification fails.
- REPORTDATA binds the signer key and a fresh nonce; RTMR3 replays from the app id and compose hash.
- Every chat reply is signed over the request and response hashes.
- The vault seals secrets with AES-256-GCM and a separate HKDF key per app. Plaintext never comes back.
- Wallet sign-in (EIP-4361), API keys and tier limits.
Simulated on devnet
Simulated on devnet- No TEE hardware yet: quotes come from a development attestor key, not Intel TDX DCAP or NVIDIA NRAS.
- The Robinhood Chain anchor transaction is computed, not sent.
- The LLM gateway returns templated answers unless an upstream confidential inference provider is configured.
- GPU offers and jobs are simulated.
The path to production: run workloads on TDX hosts with an open TEE runtime such as dstack, verify quotes with Intel DCAP and NVIDIA NRAS, deploy the attestation registry contract on Robinhood Chain, and release vault keys only to workloads that pass verification.
Getting started
Try the console in five minutes. No tokens and no gas needed.
- 01
Open the console
The enclave map, network stats and live event stream are public. Nothing to install. - 02
Connect a wallet
Robinhood Wallet, MetaMask, Rabby or any EVM wallet. The console adds Robinhood Chain (4663) if your wallet does not have it. - 03
Sign in for free
You sign a short message (EIP-4361). No transaction, no gas, nothing is moved or locked. The session lasts 7 days. - 04
Deploy a workload
In Agents, paste a docker-compose file, pick a TEE profile, add sealed environment variables and watch the boot log stream. - 05
Verify its quote
Open Attestations, pick the report, and paste your compose file: the verifier compares its hash with what was measured. - 06
Ask a sealed model
Use the Private LLM playground or the demo on the home page. Edit one word of the answer and the signature check fails.
Products
Agent sandbox, private LLM gateway, confidential GPU jobs, sealed vault and the holder pass.
Agent sandbox
Live on devnetPrivate LLM gateway
Live on devnet/v1/chat/completions, streaming or not, with a signed receipt on every reply. Catalog: DeepSeek V4.1 Flash, GLM 5.3, Kimi K3, Qwen3.8 27B, Gemma 4 31B, gpt-oss 120B. Answers are templated on devnet.Confidential GPU jobs
Simulated on devnetSealed vault
Live on devnetHolder pass
Live on devnetOn-chain anchoring
Simulated on devnetUse cases
Who Eclipseal is for, and what each of them gets.
Trading agents
Live on devnetTeams with private data
Simulated on devnetApps that need verifiable AI
Live on devnetAnyone checking a claim
Live on devnetHow a sealed run works
From docker-compose to a proof anyone can check, in five steps.
- 01
Deploy
You send a docker-compose file and sealed environment variables. The compose file is hashed into thecomposeHash. - 02
Measured boot
The confidential VM boots a known OS image while the hardware records measurements:MRTDfor the image,RTMR0toRTMR2for firmware, kernel and boot configuration,RTMR3for your app (its app id and compose hash). - 03
Quote
The enclave issues a report with those measurements and a fresh nonce bound intoREPORTDATA, then signs it. - 04
Verify
Anyone can check the signature, the signer, the TCB status, the image allowlist, the RTMR3 replay and the key binding, and compare the compose hash with their own file. - 05
Anchor
Simulated on devnetThe report digest is written to Robinhood Chain so the record outlives any server. On devnet the transaction is computed, not sent.
CPU enclaves: Intel TDX, AMD SEV-SNP
GPU enclaves: NVIDIA confidential computing
Anatomy of an attestation report
Every field in an Eclipseal report and what it proves.
| Field | What it is |
|---|---|
| id | Report id, shareable: anyone can fetch a report by id |
| subject | What was attested: a workload, model or GPU job, with its id and name |
| appId | Stable id of the app; part of the RTMR3 measurement |
| tee | CPU and GPU technology, and the platform TCB status (UpToDate or OutOfDate) |
| osImage | Name of the OS image that booted |
| measurements.mrtd | Hash of the initial VM image; must be on the verifier's allowlist |
| measurements.rtmr0-2 | Firmware, kernel and boot configuration |
| measurements.rtmr3 | Your workload: replays from appId and composeHash |
| composeHash | SHA-256 of your docker-compose file |
| imageDigest | Digest of the container image |
| nonce, reportData | Freshness: REPORTDATA commits to the signer key and the nonce |
| anchor | Robinhood Chain record: chain id, tx hash, block, status |
| signer, signature | Ed25519 public key and the signature over the canonical report |
{
"version": 1,
"id": "att_98818b4767b038c7",
"mode": "simulated",
"subject": { "type": "cvm", "id": "cvm_46426a32eb3e", "name": "atlas-trader" },
"appId": "app_12294ec29cf9224d1fc2",
"tee": { "cpu": "Intel TDX", "gpu": null, "tcbStatus": "UpToDate" },
"osImage": "eclipseal-os-0.5.4",
"measurements": { "mrtd": "65c29514…", "rtmr0": "5f7a618c…", "rtmr1": "0b5929e3…", "rtmr2": "1dd3fd00…", "rtmr3": "403b242a…" },
"composeHash": "edbea107…",
"imageDigest": "sha256:0e55054d…",
"nonce": "c8d1ada5…",
"reportData": "b4e00785…",
"issuedAt": "2026-10-23T07:01:35.026Z",
"anchor": { "chainId": 4663, "network": "Robinhood Chain", "txHash": "0x9d2ec578…", "blockNumber": 95753268, "status": "simulated" },
"signer": { "alg": "Ed25519", "publicKey": "MCowBQYDK2VwAyEA…" },
"signature": "…"
}How verification works
The checks behind a VERIFIED verdict, and how to run them yourself.
| Check | Passes when |
|---|---|
| Report signature | The Ed25519 signature matches the canonical report digest |
| Trusted attestor | The signer key is the Eclipseal attestation key |
| TCB status | The platform reports UpToDate |
| OS image (MRTD) | MRTD is on the allowlist of known images |
| Workload (RTMR3) | RTMR3 replays from the app id and compose hash |
| Key binding (REPORTDATA) | REPORTDATA commits to the signer key and the nonce |
| Compose hash | Optional: your docker-compose hashes to composeHash |
| Chain anchor | Devnet shows a warning: the anchor is computed, not on chain yet |
A report is VERIFIED when no check fails. Run it in the console under Attestations, or call the API (see the attestation quickstart).
Security model and limits
What a TEE protects, what it does not, and how Eclipseal covers the gaps.
Protects against
- The host OS, the hypervisor and the cloud operator reading enclave memory
- Other tenants on the same machine
- Silent changes to your workload: the measurements change and the quote no longer matches
- Tampered results: the signature check fails
Does not protect against
- Bugs in your own code: an app that logs or sends out its secrets will still leak them
- Physical attacks on the server. Researchers showed memory-bus interposer attacks on TDX and SEV-SNP in 2025.
- Side channels and firmware flaws until the platform is patched
Mitigations: the verifier rejects out-of-date TCBs and unknown images, operators will bond $ECLS that bad quotes can slash, and production hardware runs in vetted data centers. On your side: keep secrets in the vault, pin images by digest, and compare the compose hash before you trust an output.
API reference
REST and OpenAI-compatible endpoints on eclipseal.xyz, with authentication and limits.
Base URL https://eclipseal.xyz. The REST API lives under /api and the OpenAI-compatible gateway under /v1. Responses are JSON; errors look like { "error": "..." }, and validation errors add an issues list.
No auth
Session
POST /api/auth/nonce, sign the message, POST /api/auth/verify. Send the ecls_sess_… token as Authorization: Bearer.API key
ecls_key_… as a bearer token to /v1; your tier sets the daily quota.| Endpoint | Auth | Purpose |
|---|---|---|
| GET /api/health | None | Status, attestor public key, simulation modes |
| GET /api/network | None | Network stats and history |
| GET /api/chain | None | Live Robinhood Chain probe |
| GET /api/token | None | $ECLS status, utility and tiers |
| GET /api/tee-profiles, /api/models | None | TEE profiles and the model catalog |
| GET /api/cvms, /api/cvms/:id | Optional | Workloads: demo ones plus your own |
| POST /api/cvms | Session | Deploy a workload |
| POST /api/cvms/:id/actions | Session | start, stop, restart or attest |
| GET /api/attestations, /api/attestations/:id | None | Latest reports, or one report by id |
| POST /api/attestations/verify | None | Verify a report object or reportId, optionally with a compose file |
| POST /api/signatures/verify-chat | None | Verify a chat receipt |
| GET /api/gpu/offers, POST /api/gpu/jobs | None / Session | GPU offers and jobs |
| GET, POST, DELETE /api/secrets | Session | Sealed secrets |
| GET /api/events | Optional | Server-sent events: deploys, quotes, GPU progress, chain status |
| GET /v1/models | None | OpenAI-compatible model list |
| POST /v1/chat/completions | Key or demo | Chat completions with a signed receipt |
| GET /v1/signature/:chatId | None | Receipt for a chat |
| GET /v1/attestation/report?model= | None | Attestation report for a model |
Rate limits per IP: 600 requests a minute on /api, 120 on /v1, 40 on /v1/chat, 30 on /api/auth. Responses carry standard RateLimit headers.
Quickstart: private LLM
Point the OpenAI SDK at Eclipseal and verify the receipt that comes back.
import os
from openai import OpenAI
client = OpenAI(base_url="https://eclipseal.xyz/v1", api_key=os.environ["ECLS_API_KEY"])
reply = client.chat.completions.create(
model="deepseek/deepseek-v4.1-flash",
messages=[{"role": "user", "content": "Hello from the dark"}],
)
print(reply.choices[0].message.content)curl https://eclipseal.xyz/v1/chat/completions \
-H "Authorization: Bearer $ECLS_API_KEY" \
-H "Content-Type: application/json" \
-d '{"model":"deepseek/deepseek-v4.1-flash","messages":[{"role":"user","content":"Hello"}]}'Every reply carries a receipt: the eclipseal field in the body (the last chunk when streaming) with chat_id, request_hash, response_hash and signature, plus the headers x-eclipseal-signature and x-eclipseal-attestation. With a key, x-ecls-quota-limit and x-ecls-quota-remaining show your daily quota.
curl https://eclipseal.xyz/api/signatures/verify-chat \
-H "Content-Type: application/json" \
-d '{"model":"<model>","request_hash":"<request_hash>","response":"<the reply text>","signature":"<signature>"}'
# {"valid": true, "response_hash": "..."}Quickstart: fetch and verify a report
Three calls: list reports, fetch one, verify it.
curl "https://eclipseal.xyz/api/attestations?limit=5"curl https://eclipseal.xyz/api/attestations/<id>curl https://eclipseal.xyz/api/attestations/verify \
-H "Content-Type: application/json" \
-d '{"reportId":"<id>","compose":"<contents of docker-compose.yml>"}'
# {"valid": true, "verdict": "VERIFIED", "digest": "...", "checks": [...]}You can also send the whole report as report instead of reportId, which is how you check a report someone handed you. Devnet keeps the latest 400 reports.
$ECLS utility
What the token does today, and what is planned.
Console tiers
Live on devnetPay for compute
PlannedOperator bonds
PlannedFee buybacks
PlannedAllowlist votes
PlannedSupply and launch
Holder tiers
Live from the API: what each balance unlocks in the console.
How to get $ECLS
Bridge, open Pons, paste the official address, swap.
- 01
Get ETH on Robinhood Chain
Bridge ETH from Ethereum or another network. See the bridging guide. - 02
Open Pons
Go to ponsfamily.com and connect your wallet. - 03
Paste the official address
Search by contract address, never by name or ticker. - 04
Swap and sign in
Swap ETH for $ECLS, then sign in to the console with the same wallet to unlock your tier.
FAQ
Short answers to the questions we get most.
Is Eclipseal live?
The devnet is: the console, the verifier and signed replies work today. TEE hardware, on-chain anchoring and the GPU market come next.
Can Eclipseal or the cloud operator read my data?
On TEE hardware, software outside the enclave cannot read its memory: not the host OS, not the hypervisor, not the operator. Devnet has no TEE hardware yet, so use test values there.
Do I need $ECLS to try it?
No. The demo, the verifier and the console are open. Before launch every signed-in wallet gets Early access.
Where do I buy $ECLS?
Only on Pons, with the contract address we post on X and on this page at launch. It has not launched yet.
Is $ECLS an investment?
No. It is a utility token for an experimental product, and tokens on Pons can lose all value. Nothing here is financial advice.
Why Robinhood Chain?
It is an Ethereum L2 (Arbitrum Orbit) with low fees, which makes anchoring every run affordable, and Pons launches tokens there.
Is Eclipseal affiliated with Robinhood?
No. Eclipseal is an independent project building on a public, permissionless chain. It is not endorsed by Robinhood Markets, Inc.
Glossary
The terms used across Eclipseal.
| Term | Meaning |
|---|---|
| TEE | Trusted execution environment: an isolated part of a processor whose memory outside software cannot read |
| CVM | Confidential virtual machine: a whole VM running as a TEE |
| Intel TDX, AMD SEV-SNP | CPU technologies that run confidential VMs |
| NVIDIA CC | Confidential computing mode on Hopper and Blackwell GPUs |
| Attestation report (quote) | Signed statement of what is running inside a TEE |
| MRTD | Measurement of the initial VM image |
| RTMR0-3 | Runtime measurement registers; RTMR3 holds the workload |
| TCB | Trusted computing base: the firmware and microcode the TEE depends on |
| REPORTDATA | Field the enclave fills to bind a key and a nonce into the quote |
| DCAP, NRAS | Intel's and NVIDIA's services and libraries for checking hardware quotes |
| Anchor | The report digest recorded on Robinhood Chain |