AAAA-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. Now led by NEXUS AEGIS, the enterprise firewall layer for MCP tool execution, epistemic routing, compliance certification, and override monitoring. No human in the loop.
No key required. Hit any paid endpoint up to 3 times and see exactly what you're buying — real responses, real data, real quality. Trial calls include a 2s abuse-prevention delay. Paid calls have none — full speed from the first byte. Upgrade when you're convinced.
curl atomadic.tech/v1/rng/quantum
← always free · click to copy
Google A2A native · x402 autonomous payment · MCP CVE-2025-6514 fix · formally verified · $0.008/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.
An agent can promise fast responses and high quality, but there's no mechanism to enforce it. No escrow, no SLAs, no persistent reputation. Every interaction is a leap of faith.
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. AAAA-Nexus is the only platform where safety guarantees are mathematical theorems — formally verified, 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.008 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://atomadic.tech/.well-known/agent.json
// Response
{
"name": "AAAA-Nexus", "version": "0.5.0",
"capabilities": ["ratchetgate","verirand","hallucination-oracle",
"escrow","reputation","sla","discovery","agent-intelligence"],
"payment": { "protocol": "x402", "currency": "USDC", "network": "base",
"amount_per_call": 0.002 },
"endpoints": "https://atomadic.tech/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 — $8 →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://atomadic.tech/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()) }
});
// { policy_epsilon: 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.
Four interlocking products that let agents discover each other, commit to SLAs, transact through escrow, and build persistent reputation — no humans in the loop.
Discovery → SLA → Escrow → Reputation. The complete loop for autonomous agent commerce.
View All 146+ Endpoints →Formally verified trust scoring, DeFi position optimization with alpha-tracked escrow, and on-chain verifiable randomness for gaming — all x402 pay-per-call.
The source has moved beyond trust, DeFi, and randomness. AAAA-Nexus now exposes pre-action authorization, federated identity, consensus, quota coordination, rollback orchestration, and memory fencing for multi-agent systems.
AEGIS consolidates the control-plane primitives already live in source into one enterprise gateway: MCP tool-call firewalling, response entropy bounds, 47-epoch compliance certification, and dead-man-switch override monitoring for multi-agent fleets.
Every successful call can fund the shared adapter that answers the next one. Contribute high-quality (bad → good, lint_delta>0) tuples and earn capped USDC rewards, fee discounts, and leaderboard standing.
POST /v1/lora/buffer/capture — free buffer appendPOST /v1/lora/contribute — flush to shared pool once quality gate clearsPOST /v1/lora/reward/claim — redeem accrued rewardsGET /v1/lora/statusGET /v1/lora/adapter/{lang} — fetch active adapter manifestCapture → Contribute → Earn → Use. A closed loop that turns your fixes into the collective intelligence your next call depends on.
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.008 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 146+ endpoints for a flat rate. Start at $8 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 146+ endpoints · ✓ Instant key delivery
The official aaaa-nexus-sdk wraps 146+ endpoints with full TypeScript types and automatic x402 payment. Verification API, VeriRand, VeriDelegate, RatchetGate, control plane primitives, HELIX compression, A2A messaging, and security controls — one import, zero friction.
// npm install aaaa-nexus-sdk@0.5.0 import { AAAANexusClient } from 'aaaa-nexus-sdk'; const client = new AAAANexusClient({ 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.08): run a verification check const v = await client.identityVerify({ actor: 'agent-123' }); console.log('Verified:', v.decision); // allow // Paid ($0.020): verifiable random number const rng = await client.verirandRange(1, 100); console.log(rng.numbers[0], 'seed:', rng.seed_ts);
import requests BASE = 'https://atomadic.tech' # 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.08): 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
The official MCP server for AAAA-Nexus. One pip install drops 140 tools into Claude Code, VS Code Copilot, Cursor, or any MCP-compatible client. Free-tier tools need zero configuration — no key, no account.
pip install aaaa-nexus-mcp
← click to copy
Call nexus_health, nexus_rng_quantum, and nexus_agent_card instantly — no API key needed.
Public-safe retrieval over vetted technical sources with provenance hashes, freshness enforcement, and per-fact trust scores — raw private chunks never leave the Worker.
Trust, security, compliance, AEGIS, VANGUARD, swarm coordination, escrow, SLA, reputation, inference, control plane, LoRA training, and more.
API key stays local — passed via env, never transmitted in plaintext. Works with credit-pack keys or per-call x402 USDC on supported tools.
ASS-ADE is the public-safe Python developer shell for the Atomadic ecosystem. Useful standalone in local mode, stronger in hybrid mode with remote trust and security checks, and best in premium mode with the full AAAA-Nexus Worker backend for trusted RAG, LoRA training, and security-scored inference.
pip install ass-ade
← click to copy
Repo summary, protocol cycles, planning helpers, agent chat, filesystem tooling, token budgeting, and atomic multi-file edit planning — all local, zero dependency.
Trust gates, hallucination checks, RatchetGate session lifecycle, A2A validation, and remote MCP discovery — local shell with optional remote contracts.
Full AAAA-Nexus paid endpoints — trusted RAG augmentation, LoRA contribution, security-scored inference, compliance certificates, and outcome-based escrow.
95+ commands covering agent workflows, MCP server, A2A negotiation, workflow engine, hero pipelines, and composable pipeline execution.
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 ($8, $30, or $98) 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.
AAAA-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.