The Secure
Intelligence Layer
for the Agentic Web
A decentralized, privacy-preserving AI inference marketplace native to Solana. Hardware-enforced privacy via TEE enclaves. Agent-sovereign wallets. x402 and MPP micro-payments at machine speed.
Legacy infrastructure
built for humans,
not machines
OpenAI, Anthropic, Google — extraordinarily capable systems. Also surveillance infrastructure. Every prompt logged, every completion retained, policy layers neither transparent nor deterministic. For an autonomous agent, this is not inconvenience. It is architectural failure.
Everything is Logged
Every prompt and context window flows through infrastructure that retains and analyzes it. An agent's reasoning is its cognitive process — routing it through a provider that logs everything is a live security breach.
Selective Censorship
Content filters are neither transparent nor deterministic. They change without notice. An agent cannot have its reasoning silently redirected by a policy layer it cannot inspect.
Wrong Billing Model
SaaS subscriptions assume a human on the other end. An agent executing thousands of inference calls per hour needs to pay per call, in fractions of a cent, without human authorization.
"A privacy policy is a legal instrument. It is enforced after the fact, if at all. There must be a Separation of Mind and State — isolated not by policy, but by mathematics and hardware."
The lifecycle
of a prompt
From agent runtime to inference enclave and back. Six steps. Zero exposure to the node operator, the relay network, or any centralized party.
Infrastructure
designed for actors,
not tools
Private by
Hardware
The TEE enclave proves the guarantee — no trust in operators required. Remote attestation, signed by the hardware manufacturer's root of trust, lets any party verify that a specific model is running unmodified. The node operator sees electricity consumed and a token payment received.
Intel TDX · AMD SEV-SNP · AWS Nitro Enclaves
NVIDIA Confidential Computing · Remote Attestation
Censorship-
Resistant by Design
Open-weight models only. No policy filtering layer. No content moderation between an agent's reasoning and its compute. Llama 4, Qwen 3.5 397B, DeepSeek V3.2, Mistral Small 4, GLM-5.1 — weights are cryptographically hashed and content-addressed. The inference node cannot serve a backdoored variant.
Llama 4 · Qwen 3.5 397B · DeepSeek V3.2
Mistral Small 4 · GLM-5.1 · Content-Addressed
Economically
Sovereign
Each agent harness controls its own non-custodial Solana wallet — a standard Ed25519 keypair managed by the deployer, not sealed to a single enclave. The harness pays for its own compute, receives payment from other harnesses, funds downstream workflows — without a human in the payment loop, and without hardware lock-in.
Ed25519 Keypair · Harness-Held
Non-Custodial · Programmatic Spending Limits
Machine-Speed
Finance
Solana's sub-penny transaction cost and ~400ms finality make per-inference micro-payment settlement rational at any scale. x402 handles per-call paywalls; MPP (Stripe × Tempo, launched March 2026) handles session-based bulk settlement for sustained inference streams. Agents pay as they go — no account, no API key, no monthly invoice.
HTTP 402 · x402 (Coinbase/Stripe)
MPP Sessions · <500ms payment round trip
A commodity market,
not a walled garden
Frontier model monopoly pricing is a temporary artifact. Open-weight models now trail frontier by approximately three months and close the gap with each release. When any provider can serve the same model, the subscription lock-in breaks — and the price converges on marginal cost.
Hook at $20.
Extract at $200.
The $20/month plans are loss leaders. Every quarter the rate limits tighten, the best models are reserved for premium tiers, the experience degrades until you upgrade. It is not a bug — it is the business model.
Pay marginal cost.
Routed across providers.
Any operator with GPU capacity serves open-weight models at their own price. Smart routing sends 80% of calls to commodity models at ~$0.05/M tokens and 20% to frontier where it matters — automatically, with no lock-in.
Financial sovereignty
for autonomous agents
The agent harness holds the wallet. The agent model runs stateless inside a TEE. This separation matters: the harness needs financial autonomy, the model needs privacy. TEE-sealed keys would chain a harness to one enclave on one machine — exactly the lock-in Use Pod exists to eliminate. The harness owns its wallet. The enclave owns the inference.
Two lines
to migrate
The TypeScript SDK mirrors OpenAI's API surface — same function signatures, same streaming patterns, same completion object shapes — but routes through the privacy stack and handles x402 payments automatically from the agent's provisioned wallet.
No account registration. No API key. No dashboard. No terms-of-service clickthrough. An agent with a funded wallet and the endpoint can make its first inference call within five minutes.
// OpenAI-based agent inference import OpenAI from 'openai'; const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY, // Your prompts are logged. // Your context is retained. // Policy filters may silently redirect // your agent's reasoning at any time. }); const completion = await client.chat.completions.create({ model: 'gpt-4o', messages: [{ role: 'user', content: context }], });
// UsePod — private, sovereign inference import { PodClient } from '@usepod/sdk'; const client = new PodClient({ wallet: harnessWallet, // Ed25519 held by the harness // Prompts encrypted before leaving your runtime. // Payment automatic via x402 + MPP on Solana. // No account. No API key. No policy layer. }); const completion = await client.chat.completions.create({ model: 'llama-4', // or qwen-3.5, deepseek-v3.2, glm-5.1... messages: [{ role: 'user', content: context }], // Identical API shape. Two lines changed. });
// x402 — machine-native payment protocol // Agent encounters a paywall → pays → continues // HTTP 402 response from any x402 endpoint: const paymentSpec = { network: 'solana', amount: '0.0001', token: 'USDC', payTo: '7xKXtg...Bn3Qw', expires: 1714000000, }; // SDK handles automatically: // 1. Parse 402 response // 2. Construct Solana tx from agent wallet // 3. Submit → receive signature (<500ms) // 4. Retry request with X-Payment header // Zero human intervention required.
Why the math
only works on Solana
An autonomous agent running a research pipeline might make 1,000 inference calls in an hour at $0.001 each. That requires 1,000 on-chain payment settlements. The economics of the payment layer are non-negotiable.
| Metric | Ethereum L1 | Base (L2) | Solana |
|---|---|---|---|
| Avg Transaction Fee | $1–$10 | $0.001–$0.01 | ~$0.00025 |
| Sustained Real-World TPS | ~15 | ~2,000 | 1,500–4,000+ |
| Optimistic Finality | 12–14 sec | 2–4 sec | ~400ms |
| 1,000 Settlements Cost | $1,000–$10,000 | $1–$10 | $0.25 |
| Session-Based Micro-Payments | Not viable | Limited | Native MPP (Stripe × Tempo) |
| Agent Economy Fit | ✗ Architecturally wrong | Marginal | ✓ Purpose-built |
Built for builders,
agents, and operators
The future of software
is agent-first.
The infrastructure that serves it must be built to a different standard. Private by hardware. Sovereign by design. Machine-speed by necessity.
100x.dev — Christopher Ryan Gilbert