Documentation

Eclipseal docs

How sealed compute works, how to verify what ran, how to build on the API, and what $ECLS does. Start with devnet status to see what is live.

NETWORK
Robinhood Chain
CHAIN ID
4663
STAGE
Devnet
$ECLS
Pre-launch
Start here#overview

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

AI clouds can read prompts, model weights and the keys your agents hold. For an agent that trades, that is not a privacy problem, it is a custody problem.

The approach

Run the workload in a confidential VM (Intel TDX or AMD SEV-SNP), with NVIDIA confidential computing for GPU work. Secrets are sealed to the measured workload.

The proof

Each run produces a signed attestation report. Anyone can verify it, and its digest is anchored on Robinhood Chain (chain 4663).

$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.

Start here#devnet-status

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.
Devnet runs on an ordinary server. Do not seal real keys or put private data into it; use test values until workloads run on TEE hardware.

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.

  1. 01

    Open the console

    The enclave map, network stats and live event stream are public. Nothing to install.
  2. 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.
  3. 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.
  4. 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.
  5. 05

    Verify its quote

    Open Attestations, pick the report, and paste your compose file: the verifier compares its hash with what was measured.
  6. 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.
Start here#products

Products

Agent sandbox, private LLM gateway, confidential GPU jobs, sealed vault and the holder pass.

Agent sandbox

Live on devnet
Deploy any docker-compose into a confidential VM profile: TDX Small, Medium or Large, SEV-SNP, or TDX with an H100 or H200. Secrets are injected as sealed environment variables, and every boot produces a quote that includes your compose hash.

Private LLM gateway

Live on devnet
OpenAI-compatible /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 devnet
H100, H200 and B300 offers with NVIDIA confidential computing on. Launch fine-tuning or eval jobs with a cost estimate and live progress. Real hardware comes with the confidential GPU market.

Sealed vault

Live on devnet
Seal API keys and credentials once; the console never shows them again. Planned: release keys only to workloads whose attestation passes.

Holder pass

Live on devnet
Your $ECLS balance on Robinhood Chain sets your tier: discounts, daily LLM requests, workloads and GPUs per job. See holder tiers.

On-chain anchoring

Simulated on devnet
Report digests anchored on Robinhood Chain so anyone can check what ran and when. On devnet the transaction is computed; on-chain writes start with the registry contract.
Start here#use-cases

Use cases

Who Eclipseal is for, and what each of them gets.

Trading agents

Live on devnet
Keys and strategy stay inside the enclave, out of reach of the host. Every boot comes with a quote you can show the people who trust your agent with funds.

Teams with private data

Simulated on devnet
Fine-tune or evaluate on data you are not allowed to share. The GPU is attested before your data loads, and checkpoints are sealed to your key.

Apps that need verifiable AI

Live on devnet
Call an OpenAI-compatible endpoint and keep the signed receipt of each answer, so your users can check that a reply was not changed on the way.

Anyone checking a claim

Live on devnet
Paste a report into the verifier to see what ran, on which image, with which compose file. No account and no wallet needed.
How it works#how-it-works

How a sealed run works

From docker-compose to a proof anyone can check, in five steps.

  1. 01

    Deploy

    You send a docker-compose file and sealed environment variables. The compose file is hashed into the composeHash.
  2. 02

    Measured boot

    The confidential VM boots a known OS image while the hardware records measurements: MRTD for the image, RTMR0to RTMR2 for firmware, kernel and boot configuration, RTMR3 for your app (its app id and compose hash).
  3. 03

    Quote

    The enclave issues a report with those measurements and a fresh nonce bound into REPORTDATA, then signs it.
  4. 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.
  5. 05

    Anchor

    Simulated on devnet
    The 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

Confidential VMs whose memory the processor encrypts with keys it never releases. The host OS, the hypervisor and other tenants cannot read it, and the processor measures what boots.

GPU enclaves: NVIDIA confidential computing

Hopper (H100, H200) and Blackwell GPUs in CC mode. Traffic between the CPU enclave and the GPU is encrypted, GPU memory is walled off from the host, and the GPU produces its own attestation, checked against NVIDIA's attestation service.

Anatomy of an attestation report

Every field in an Eclipseal report and what it proves.

FieldWhat it is
idReport id, shareable: anyone can fetch a report by id
subjectWhat was attested: a workload, model or GPU job, with its id and name
appIdStable id of the app; part of the RTMR3 measurement
teeCPU and GPU technology, and the platform TCB status (UpToDate or OutOfDate)
osImageName of the OS image that booted
measurements.mrtdHash of the initial VM image; must be on the verifier's allowlist
measurements.rtmr0-2Firmware, kernel and boot configuration
measurements.rtmr3Your workload: replays from appId and composeHash
composeHashSHA-256 of your docker-compose file
imageDigestDigest of the container image
nonce, reportDataFreshness: REPORTDATA commits to the signer key and the nonce
anchorRobinhood Chain record: chain id, tx hash, block, status
signer, signatureEd25519 public key and the signature over the canonical report
Example report (shortened)
{
  "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 it works#verification

How verification works

The checks behind a VERIFIED verdict, and how to run them yourself.

CheckPasses when
Report signatureThe Ed25519 signature matches the canonical report digest
Trusted attestorThe signer key is the Eclipseal attestation key
TCB statusThe 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 hashOptional: your docker-compose hashes to composeHash
Chain anchorDevnet 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).

How it works#security-model

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.

Developers#api-reference

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

Public reads, the verifier, and the rate-limited demo of the LLM gateway.

Session

Sign in with a wallet: POST /api/auth/nonce, sign the message, POST /api/auth/verify. Send the ecls_sess_… token as Authorization: Bearer.

API key

Create up to 5 keys in the console under Private LLM. Send ecls_key_… as a bearer token to /v1; your tier sets the daily quota.
EndpointAuthPurpose
GET /api/healthNoneStatus, attestor public key, simulation modes
GET /api/networkNoneNetwork stats and history
GET /api/chainNoneLive Robinhood Chain probe
GET /api/tokenNone$ECLS status, utility and tiers
GET /api/tee-profiles, /api/modelsNoneTEE profiles and the model catalog
GET /api/cvms, /api/cvms/:idOptionalWorkloads: demo ones plus your own
POST /api/cvmsSessionDeploy a workload
POST /api/cvms/:id/actionsSessionstart, stop, restart or attest
GET /api/attestations, /api/attestations/:idNoneLatest reports, or one report by id
POST /api/attestations/verifyNoneVerify a report object or reportId, optionally with a compose file
POST /api/signatures/verify-chatNoneVerify a chat receipt
GET /api/gpu/offers, POST /api/gpu/jobsNone / SessionGPU offers and jobs
GET, POST, DELETE /api/secretsSessionSealed secrets
GET /api/eventsOptionalServer-sent events: deploys, quotes, GPU progress, chain status
GET /v1/modelsNoneOpenAI-compatible model list
POST /v1/chat/completionsKey or demoChat completions with a signed receipt
GET /v1/signature/:chatIdNoneReceipt for a chat
GET /v1/attestation/report?model=NoneAttestation 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.

Developers#api-llm

Quickstart: private LLM

Point the OpenAI SDK at Eclipseal and verify the receipt that comes back.

Python, OpenAI SDK
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
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.

Verify a receipt
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.

1. List the latest reports
curl "https://eclipseal.xyz/api/attestations?limit=5"
2. Fetch one by id
curl https://eclipseal.xyz/api/attestations/<id>
3. Verify it, optionally against your compose file
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.

Token & holders#token-utility

$ECLS utility

What the token does today, and what is planned.

Console tiers

Live on devnet
Hold $ECLS in the wallet you sign in with and the console reads the balance on Robinhood Chain to set your tier. Nothing is staked or locked.

Pay for compute

Planned
Settle workloads, GPU jobs and inference in $ECLS at a discount.

Operator bonds

Planned
Node operators bond $ECLS to list TEE hardware. Invalid quotes or failed attestations get slashed.

Fee buybacks

Planned
A share of protocol fees buys $ECLS from its Pons pool.

Allowlist votes

Planned
Holders vote on which OS images and GPU firmware the verifier trusts.

Supply and launch

Fixed supply of 1,000,000,000 on Pons. Pons launches start on a bonding curve that graduates into a permanently locked Uniswap v4 pool.
Planned mechanics can change before they ship. $ECLS is an experimental token on a new chain and can lose all of its value. Nothing in these docs is financial advice.
Token & holders#holder-tiers

Holder tiers

Live from the API: what each balance unlocks in the console.

Token & holders#how-to-get

How to get $ECLS

Bridge, open Pons, paste the official address, swap.

  1. 01

    Get ETH on Robinhood Chain

    Bridge ETH from Ethereum or another network. See the bridging guide.
  2. 02

    Open Pons

    Go to ponsfamily.com and connect your wallet.
  3. 03

    Paste the official address

    Search by contract address, never by name or ticker.
  4. 04

    Swap and sign in

    Swap ETH for $ECLS, then sign in to the console with the same wallet to unlock your tier.
Not launched yet. The contract address will be posted on @eclipseal_ai and on this page the moment the Pons launch confirms. Any address you see before that is not ours. Names and tickers on Pons can be copied; the address is the only identity.
Reference#faq

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.

Reference#glossary

Glossary

The terms used across Eclipseal.

TermMeaning
TEETrusted execution environment: an isolated part of a processor whose memory outside software cannot read
CVMConfidential virtual machine: a whole VM running as a TEE
Intel TDX, AMD SEV-SNPCPU technologies that run confidential VMs
NVIDIA CCConfidential computing mode on Hopper and Blackwell GPUs
Attestation report (quote)Signed statement of what is running inside a TEE
MRTDMeasurement of the initial VM image
RTMR0-3Runtime measurement registers; RTMR3 holds the workload
TCBTrusted computing base: the firmware and microcode the TEE depends on
REPORTDATAField the enclave fills to bind a key and a nonce into the quote
DCAP, NRASIntel's and NVIDIA's services and libraries for checking hardware quotes
AnchorThe report digest recorded on Robinhood Chain