SableNetwork
Dashboard
Confidential AI Infrastructure

Private inference, for the agent economy.

Sable Network is an OpenAI-compatible inference layer that encrypts prompts in flight, routes them across confidential compute, and never persists what your agents reason about.

Get an API keyRead the quickstart
Drop-in
OpenAI API
Encryption
AES-256-GCM
Models
Llama · DeepSeek · Mistral
from openai import OpenAI

# Replace the OpenAI client. Nothing else changes.
client = OpenAI(
    base_url="https://api.sable.network/v1",
    api_key="sk-sable_...",
)

response = client.chat.completions.create(
    model="sable-llama-3.3-70b",
    messages=[{"role": "user", "content": "Analyze this report."}],
)
print(response.choices[0].message.content)

Swap OpenAI() for Sable(). Nothing else changes.

Live
Sealed847,201
p50142ms
Nodes4/4
Routing across
Llama 3.3 70B·meta
Llama 3.1 8B·meta
DeepSeek V3·deepseek
DeepSeek R1·deepseek
Mistral Large·mistral
Mixtral 8x22B·mistral
Qwen 2.5 72B·qwen
Qwen 2.5 Coder·qwen
GPT-4o mini·openai
Hermes 3·nous
Llama 3.3 70B·meta
Llama 3.1 8B·meta
DeepSeek V3·deepseek
DeepSeek R1·deepseek
Mistral Large·mistral
Mixtral 8x22B·mistral
Qwen 2.5 72B·qwen
Qwen 2.5 Coder·qwen
GPT-4o mini·openai
Hermes 3·nous
Core protocol

The trust layer for AI.

Sable replaces the centralized assumption baked into every AI provider today. Encryption, routing, and execution are protocol-level — not policies in a privacy page.

Privacy first

Confidential inference

Prompts are sealed with AES-256-GCM on ingress. Compute nodes execute against the sealed envelope and have no view of prompt, memory, or output.

Routing layer

Decentralized compute

Workloads route across a global fabric of GPU operators selected by latency, jurisdiction, cost, and privacy tier.

TEE-ready

Trusted execution

Confidential computing on Intel SGX, AMD SEV, and NVIDIA Confidential Computing isolates inference inside attested enclaves.

Phase 3

Verifiable inference

Cryptographic attestations let agents confirm the right model ran and the output was untampered. ZK proofs become the long-term substrate.

Developer-first

OpenAI-compatible

Swap one base URL. The full ecosystem of SDKs, agents, and tools works unchanged. Migration is the same line of code.

Sovereign agents

Agent-native primitives

Private memory, signed reasoning, multi-turn confidentiality. Sable is the substrate for the autonomous-agent economy.

Network architecture

Four layers. One privacy contract.

Every layer enforces the same invariant: nobody between the developer and the model can read the prompt.

L101 / 4

User Layer

Where developers integrate.

  • Agents
  • SDKs
  • Applications
  • OpenAI clients
L202 / 4

Routing Layer

Selects the right node for every request.

  • Privacy tier
  • Latency
  • Jurisdiction
  • Trust score
L303 / 4

Compute Layer

Confidential execution at scale.

  • GPU operators
  • vLLM / TensorRT
  • Open-source models
  • Stake-secured
L404 / 4

Verification Layer

Integrity for every output.

  • TEE attestation
  • Proof-of-inference
  • ZK roadmap
Client
OpenAI SDK
Sable Gateway
seal · route
Confidential Node
TEE · model
Thesis

AI infrastructure should be trusted, not trusting.

Centralized AI is a privacy liability.

Every prompt is a leak surface. Trading strategies, medical records, internal source code, agent memory — all of it passes through provider logs and human review pipelines today.

Agents change the threat model.

Autonomous systems run thousands of inferences per hour against private state. The unit economics of human review do not survive contact with machine-scale workloads.

Privacy must be protocol-level.

Trust-me APIs do not generalize. Sable encodes confidentiality into the routing fabric so it holds regardless of who operates the compute.

Trajectory

A protocol, not a product.

We're shipping the inference layer first because that's where the pain is real today. The rest of the stack composes on top.

Phase 1Live

Private inference API

  • OpenAI-compatible chat completions
  • Encrypted transport with AES-256-GCM
  • API keys + privacy tiers
  • Privacy dashboard with metadata-only logs
01
Phase 2Q3 2026

Confidential compute

  • TEE integration (SGX · SEV · NVIDIA-CC)
  • Stake-secured node operators
  • Node reputation + slashing
  • Model marketplace
02
Phase 3Q1 2027

Verifiable inference

  • Proof-of-inference attestations
  • ZK execution proofs
  • Enterprise deployment surface
  • Autonomous agent execution layer
03
Phase 4Beyond

Sovereign intelligence

  • Decentralized GPU marketplace
  • Cross-jurisdiction routing
  • Machine-to-machine economy primitives
  • Sovereign deployments
04
Start now

Ship private inference today.

Create an API key in under a minute. Keep your existing OpenAI code. Route every request through Sable.

Create an API keyOpen the docs