Verify
Verify Real End-to-End Private AI.
Three Proof Layers.
Private AI is real only when the model runs inside GPU confidential compute, the model host proves the privacy boundary, and the gateway itself is verifiable. RedPill checks those layers before it routes your request.
Real end-to-end private AI means every privacy boundary has proof.
1. GPU TEE Model Runtime
The model path must run in confidential GPU infrastructure, such as NVIDIA Confidential Compute behind a CPU TEE.
2. Model Host Proof
The provider must expose attestation that binds the live workload to a TLS SPKI or E2EE public key the gateway can enforce.
3. Gateway Proof
The RedPill gateway publishes its own attestation report, keyset, signed receipts, and attested upstream sessions.
From the Private AI Gateway code: a provider is never accepted as verified without an enforceable channel binding. If the selected backend cannot enforce that binding on the actual request path, forwarding fails closed.
Verify Each Step of Private Inference
The same client workflow verifies RedPill and every supported TEE provider, even when the provider proof format is different.
GET /v1/attestation/report?nonce=<fresh>
RedPill Is the Verification Layer Across TEE AI Providers
The gateway repo audits each provider against the same bar: workload identity, enforceable channel binding, privacy boundary, runtime policy, receipts, and attested sessions.
5+1
TEE providers reviewed
Tinfoil, NEAR AI, Chutes, SecretAI, PhalaDirect, ACI service
2
binding types normalized
TLS SPKI pinning and upstream E2EE public-key binding
1
verification workflow
gateway report, receipt, attested session, enforced route
Verify the provider
Provider adapters verify TDX, SEV-SNP, dstack, Tinfoil SDK, SecretVM, or Chutes evidence according to the provider report.
Enforce the binding
The gateway only forwards when the verified TLS SPKI or E2EE key can be enforced on the live request path.
Leave an audit trail
Every provider-backed response can carry a receipt that links the route, upstream verification event, response hash, and attested session.
Tinfoil
Confidential router
TEE proof
AMD SEV-SNP or TDX plus NVIDIA CC; official Tinfoil SDK checks Sigstore provenance, hardware quote, measurement, TCB, and TLS key binding.
Binding
tls_spki_sha256What RedPill adds
Pins the verified router channel before forwarding and records the provider verification in receipts and attested sessions.
NEAR AI
Verified gateway channel
TEE proof
Intel TDX plus NVIDIA CC; gateway attestation binds nonce, signing address, and TLS SPKI. Nested model attestations are delegated to the verified gateway.
Binding
tls_spki_sha256What RedPill adds
Treats catalog flags as advisory, verifies the gateway channel, and records served model identity honestly at receipt level.
Chutes
Direct E2EE model instance
TEE proof
Intel TDX plus NVIDIA CC; DCAP quote binds nonce and E2EE public key, then NVIDIA NRAS evidence is nonce-checked.
Binding
e2ee_public_key_sha256What RedPill adds
Encrypts each request to a verified instance key and fails closed when no verified nonce/key session is available.
SecretAI
Direct SecretVM origin
TEE proof
SEV-SNP or TDX plus NVIDIA CC; CPU quote binds inference TLS SPKI, GPU nonce, measured SecretVM workload, and optional workload ID pin.
Binding
tls_spki_sha256What RedPill adds
Normalizes SecretVM evidence into the same lease, binding, receipt, and session model used by other providers.
PhalaDirect
Direct dstack model endpoint
TEE proof
Intel TDX plus NVIDIA CC through Phala dstack; version-2 report binds nonce, signing address, compose hash, and custom-domain TLS SPKI.
Binding
tls_spki_sha256What RedPill adds
Derives the TLS pin from the verified report instead of static config, then enforces it before sending the prompt.
ACI service
First-party ACI-compatible server
TEE proof
Intel TDX plus NVIDIA CC using the same `/v1/attestation/report` surface and ACI session semantics.
Binding
tls_spki_sha256What RedPill adds
Uses the native ACI evidence shape directly, so clients get the cleanest gateway, receipt, and session verification path.
This is why RedPill can be more than a TEE model catalog: it aggregates different confidential-compute providers into one OpenAI-compatible API, but keeps the security bar uniform and auditable for every routed request.
Honest Privacy Means Clear Proof Boundaries
RedPill is strongest where it can verify both sides of the private inference path: the model host and the gateway that routes to it.
Normal API Compatibility
Use the same OpenAI-compatible request path while RedPill handles provider verification, route selection, and receipt issuance.
Independent Verification
A relying party checks the gateway report, upstream event, enforceable binding, receipt signature, and response hash.
Optional ACI E2EE
Selected request and response fields can be encrypted to keys from the attested gateway keyset when TLS alone is not enough.
What We Do Not Hide
RedPill only treats an upstream as private when its adapter verifies provider identity and enforces channel binding.
Optional middleware sees plaintext after gateway decryption and must be inside the same attested deployment and audit boundary.
Receipts are implemented with configurable TTL, but durable public transparency logging is not implemented yet.
Policy-Only AI vs Verifiable Private AI
Privacy policies are useful. Receipts, channel bindings, and audit sessions are testable.
Standard AI API
Plain hosted inference
Privacy-Policy AI
Promise-based privacy
RedPill
Private AI evidence
Built for Professionals
For industries where confidentiality isn't optional, RedPill delivers AI that respects your professional obligations.
- For Lawyers
- For Healthcare
- For Finance
- For Executives
Open Source Where It Matters
Audit the gateway, run the verifier, inspect the chat UX, and track signed receipts as a developer-preview proof layer.
Get an API key in 2 minutes
Start with the OpenAI SDK, choose a private model, and add verifier checks when you need audit-grade proof.
Get API KeyEnd-to-end encrypted AI through one gateway: private models, verified providers, unified pricing, live performance, and evidence your team can check.