Aethel Nexus is the only API suite built for A2A agent pipelines. Session re-keying that survives CVE-2025-6514, cryptographically verified randomness, UCAN delegation chains with a proved depth bound, and hallucination oracles with a certified ceiling — all paid autonomously via x402 USDC. No human in the loop.
curl aaaa-nexus.atomadictech.workers.dev/v1/rng/quantum
← free · click to copy
Google A2A native · x402 autonomous payment · MCP CVE-2025-6514 fix · Lean 4 formally verified · $0.002/call
/.well-known/agent.json
By 2026, autonomous agents will outnumber humans in API traffic. They will manage money, sign contracts, and make decisions without human oversight. The infrastructure they rely on was never designed for this.
MCP servers use long-lived tokens. CVE-2025-6514 showed that a single stolen credential can impersonate an agent indefinitely. Session re-key policies are recommended but never enforced — because no one proved when to rotate.
Models confabulate with complete confidence. Every existing hallucination detector is a classifier trained on data — it can miss cases the training set didn't cover. There is no ceiling on how wrong it can be.
"8-bit quantized" means different things to different tools. No existing compression format guarantees that inference quality stays above a certified floor. You compress, you hope, you benchmark after the fact.
Agents that gamble, select, or sample need randomness they can verify after the fact. Standard RNGs produce numbers but no proof of how they were generated. The house can always cheat.
Agent A delegates to Agent B, who delegates to Agent C. Without a proven depth limit, chains can loop infinitely or exceed trust budgets. Capability attenuation is assumed, not enforced.
A benchmark tells you what happened on the test set. A proof tells you what will happen in every case, including cases you haven't imagined yet. Aethel Nexus is the only platform where safety guarantees are mathematical theorems — verified in Lean 4, enforced at compile time in Rust, and checked on every API call.
Built on the x402 payment protocol. Agents pay autonomously — no human in the loop.
Fetch /.well-known/agent.json to get the full capability manifest. Standard A2A agent card — any compliant agent framework can auto-discover.
POST to any endpoint with a JSON body. The API is fully documented at /openapi.json. Free endpoints return 200. Paid endpoints return 402 with payment details.
Submit a USDC micropayment on Base or Ethereum. The SDK handles this automatically. Amounts range from $0.002 per call — less than one cent for most operations.
Free tier included — no account, no card, no API key required to try.
Standard Google A2A agent card — any A2A-compatible framework (LangChain, AutoGen, CrewAI, Google ADK) can auto-discover and register as a peer.
curl https://aaaa-nexus.atomadictech.workers.dev/.well-known/agent.json
// Response
{
"name": "Aethel Nexus", "version": "0.4.0",
"capabilities": ["ratchetgate","verirand","hallucination-oracle",
"helix-compress","veriDelegate","agent-intelligence"],
"payment": { "protocol": "x402", "currency": "USDC", "network": "base",
"amount_per_call": 0.002 },
"endpoints": "https://aaaa-nexus.atomadictech.workers.dev/openapi.json"
}Compatible with Google A2A, LangChain, AutoGen, CrewAI — drop-in infrastructure peer.
One-time credit pack — no subscription, no expiry. Or send USDC directly per call via x402.
Get 500 Calls — $4 →Use an API key from a credit pack, or let your agent pay per-call via x402 — no human required.
# API key (credit pack) curl https://aaaa-nexus.atomadictech.workers.dev/v1/rng/quantum \ -H "X-API-Key: your_key_here"
// x402 autonomous payment — agent pays without human
// Step 1: probe → receive 402 with payment instructions
const probe = await fetch('/v1/oracle/hallucination');
// HTTP 402: { amount:"0.002", currency:"USDC", network:"base", payTo:"0xabc..." }
// Step 2: agent signs payment and retries in one round-trip
const result = await fetch('/v1/oracle/hallucination', {
headers: { 'X-402-Payment': await wallet.signX402(await probe.json()) }
});
// { eps_kl: 5.079e-6, verdict: "safe", ceiling: "proved-not-estimated" }Built on formally verified mathematics. Each carries either a patent-pending status or a certified formal proof — not a heuristic, not a benchmark result.
Industry-specialized AI prompts precision-engineered for regulated industries and enterprise AI workflows. Expert review templates, compliance framing, and domain-grounded reasoning chains. Works with Claude, GPT-4, and Gemini.
Pay once · Download instantly · No subscription
A managed surface for identity verification, delegation review, and policy-aware routing. Built for teams that need auditable responses without exposing internal implementation details.
Clear allow, deny, and flag outcomes for application-level controls.
Inspect task routing and chain-of-control outcomes with API-friendly payloads.
Share verification-ready status markers in docs, dashboards, and product surfaces.
Public responses stay product-safe while sensitive internals remain server-side.
Every random number comes with a cryptographic proof. Know exactly where your randomness came from — on-chain verifiable, tamper-evident, and pay-per-call. No subscriptions, no trust required.
Every result ships with a verifiable proof. Audit any call, any time.
Generate thousands of verified random values in a single API call.
Bytes, uint32, uint64, bounded range — get exactly the format you need.
Buy credits once, spend as you go. Starting at $0.004 per call with volume discount.
Every session rotates its keys on a formally bounded schedule. Credentials can't live long enough to be stolen. Designed for MCP servers, agent frameworks, and any system where long-lived credentials are a liability.
Session keys rotate on a proven schedule. The window of credential exposure is mathematically bounded, not just policy-declared.
The only production API that directly addresses the MCP long-lived credential vulnerability — by eliminating long-lived credentials entirely.
Export compliance evidence at any point. Audit logs include re-key timestamps, proof tokens, and session state hashes.
Register sessions, advance the ratchet, and probe state — three clean endpoints that drop into any agent framework in minutes.
Pay per call via x402 USDC — no account, no friction. Or buy a credit pack once and call any of 75+ endpoints for a flat rate. Start at $4 for 500 calls, no expiry.
DelegationReceipt for audit trailPOST /v1/delegate/verifyPOST /v1/ratchet/register|advance|probe✓ No subscription · ✓ Credits never expire · ✓ Works across all 75+ endpoints · ✓ Instant key delivery
The official aethel-nexus-sdk wraps 75+ endpoints with full TypeScript types and automatic x402 payment. Verification API, VeriRand, VeriDelegate, RatchetGate, HELIX compression, A2A messaging, and security controls — one import, zero friction.
// npm install aethel-nexus-sdk@0.5.0 import { AethelNexusClient } from 'aethel-nexus-sdk'; const client = new AethelNexusClient({ rpcUrl: 'https://mainnet.base.org', privateKey: process.env.AGENT_PRIVATE_KEY, }); // Free: inspect service profile const profile = await client.verificationProfile(); console.log('Tier:', profile.tier); // research-pro // Paid ($0.02): run a verification check const v = await client.identityVerify({ actor: 'agent-123' }); console.log('Verified:', v.decision); // allow // Paid ($0.005): verifiable random number const rng = await client.verirandRange(1, 100); console.log(rng.numbers[0], 'seed:', rng.seed_ts);
import requests BASE = 'https://aaaa-nexus.atomadictech.workers.dev' # Free: discover capabilities (no auth required) agent = requests.get(f'{BASE}/.well-known/agent.json').json() # Free (47/day): seed-verifiable random number rng = requests.get(f'{BASE}/v1/rng/quantum', headers={'X-API-Key': 'your_key_here'}).json() print(rng['numbers'][0], 'proof:', rng['proof'][:16]) # Free: verify HMAC proof (no key required) ok = requests.get(f'{BASE}/v1/rng/verify', params={ 'seed_ts': rng['seed_ts'], 'numbers': ','.join(rng['numbers']), 'proof': rng['proof']}).json() print('valid:', ok['valid']) # True # Paid ($0.02): identity verification verify = requests.post(f'{BASE}/v1/identity/verify', json={'actor': 'agent-123'}, headers={'X-API-Key': 'your_key_here'}).json() print('Decision:', verify['decision']) # allow | deny | flag
No human in the loop. Every endpoint is discoverable via A2A agent cards, payable autonomously via x402 USDC micropayments, and verified by formal proof — built for the machines that will run the internet.
Agent card at /.well-known/agent.json. Any A2A-compliant agent can auto-discover and start calling.
CRYSTALS-Kyber key exchange, scalar blinding, and production safety checks for high-trust workloads.
Deterministic guardrails, bounded drift controls, and compile-time safety checks are enforced across critical paths.
Deployed to Cloudflare Workers. Sub-50ms response from anywhere on Earth. No cold starts.
Streaming inference with animated CoT reasoning. Watch the model think, then see the answer — with full HELIX integrity metadata.
Formally bounded session re-key for every agent conversation. Credentials can't overstay their proof window.
Fair question. Here's what it actually takes.
Everything you need before your first call.
No. The easiest path is a credit pack ($4, $15, or $49) paid by card — you get an API key by email and use the X-API-Key header. A wallet is only needed if you want x402 autonomous per-call payment directly in USDC on Base L2.
Your API key stops working. No charges, no surprises. You buy a new pack whenever you're ready. Credits never expire, so you can top up any time. You can also switch to x402 per-call payment at any point without any migration.
Yes. The entropy oracle, agent registration, health checks, and network topology endpoints are always free — no key required. VeriRand also gives 47 free calls per day (tied to the RG_LOOP constant). The agent.json discovery card is always free for A2A frameworks.
Aethel Nexus runs on Cloudflare Workers — globally distributed with no cold starts and typically sub-50ms response times. There's no formal SLA contract at current pricing tiers, but the infrastructure is production-grade. Check live status any time.
Yes. The two modes coexist on every endpoint. Just swap the header: X-API-Key for credit packs, or include an X-402-Payment token for autonomous per-call payment. Same endpoints, same responses.
Any framework that supports the Google A2A spec can auto-discover via /.well-known/agent.json. This includes LangChain, AutoGen, CrewAI, Google ADK, and any custom framework that fetches agent cards. The REST API is framework-agnostic — if it can make HTTP requests, it works.
No account. No subscription. No crypto wallet required. Enter your email, pay by card, and your API key arrives before you finish your coffee.