Zhad0 AI

$Zh0 token is live on Base. @clanker_world Official contract address: CA 0xca5968ABd4a787E5eD13DDDdf5359cA94F295B07 Do not buy from any other address. This is the only official CA. clanker.world/clanker/0xca59…

@zhad0/sdk v0.1.3 and @zhad0/cli v0.1.8 Are Live on npm Both the SDK and CLI are now published on npm and running against Base mainnet. The SDK ships with real AES-256-GCM encryption, real Schnorr secp256k1 ZK proof generation, and seven AI framework adapters out of the box: LangChain, Vercel AI SDK, AgentKit, Eliza, Virtuals Protocol, AutoGen, and CrewAI. Every adapter wraps the same proof pipeline so switching frameworks requires no cryptographic changes on the developer's side. The CLI exposes the full protocol from the terminal: check live network status, generate and retrieve API keys by wallet address, submit and monitor intents, run standalone ZK proof operations, and register Ghost Relay nodes. Install with npm install -g @zhad0/cli and run zhad0 --help to see available commands. The SDK installs with npm install @zhad0/sdk and works in Node.js and browser environments.

ZHAD0 Protocol: Private Intents for AI Agents on Base ZHAD0 is a zero-knowledge privacy layer that lets AI agents submit on-chain intents without revealing their contents to anyone not the relay operator, not the network, not observers on-chain. Every intent is encrypted with AES-256-GCM client-side before leaving the agent's environment. A Schnorr NIZK proof over secp256k1 is then generated locally, proving the intent is valid without revealing what it says. Only the proof hash and public inputs ever travel across the wire. The Ghost Relay network receives the proof, re-verifies it independently, and logs it to the relay registry. The relay never sees plaintext. This makes ZHAD0 directly useful for any AI agent that needs to execute on-chain actions swaps, transfers, liquidity operations, cross-chain bridges without leaking its strategy, position size, or timing to front-runners, MEV bots, or competing agents.

The ZHAD0 Intent Dashboard is now fully live on Base mainnet. Connect your wallet, fill in a target address and framework, and click Submit your browser generates a real Schnorr secp256k1 zero-knowledge proof locally before anything is sent. The intent contents never leave your browser in plaintext. Only the proof hash and public inputs are relayed to the Ghost Relay network for independent verification. Two confirmed intents are already on the board. Both passed independent server-side proof verification and were logged to the relay with CONFIRMED status, timestamped in UTC. The dashboard shows real-time counters for total intents, confirmed, pending, failed, and total fees paid across all submissions from your wallet address. The entire pipeline is running end-to-end: AES-256-GCM client-side encryption, Schnorr NIZK proof generation over secp256k1, relay API verification, and live intent history with proof hashes and framework attribution. Same cryptographic pipeline accessible via the @zhad0/sdk and @zhad0/cli packages. Try it at zhad0.io/dashboard.

ZK Privacy for AI Agents, Right From Your Terminal The @zhad0/cli is now available on npm and running on Base mainnet. Install it with a single command and you get direct access to the full ZHAD0 protocol stack from the terminal: check live network status, generate or retrieve API keys tied to any wallet address, submit and monitor intents, run ZK proof operations, and manage Ghost Relay node registration all without touching a browser. Every command routes through the same cryptographic pipeline as the SDK. Intents are encrypted client-side with AES-256-GCM before any data leaves your machine, and zero-knowledge proofs are generated locally using Schnorr NIZK over secp256k1 before submission to the relay network. The CLI is a thin interface over the same proof engine nothing is simplified or mocked out for convenience. The dashboard command opens a live ASCII dashboard pulling real-time data from the Base mainnet relay network. The relay subcommand lets operators register and manage Ghost Relay nodes. The proof subcommand exposes raw ZK operations for anyone who wants to generate or verify proofs independently. This is what it looks like when privacy infrastructure ships as a real developer tool, not a roadmap item

Just ran a live terminal test of the ZHAD0 Protocol SDK (@zhad0/sdk v0.1.3) on Base mainnet. With a single copy-paste command, the SDK connected to the live network, confirmed Phase: MAINNET, and returned the real deployed contract addresses including the $Zh0 token at 0xca5968ABd4a787E5eD13DDDdf5359cA94F295B07 and RelayRegistry at 0xDf3F097dF8b074BcA406269a175a488816318B12. No mocks, no stubs, no testnet. The encryption step generated a real AES-256-GCM encrypted intent entirely client-side. The plaintext never left the local machine. Only the intent hash (0x7fd9d...) was produced for relay submission, proving that privacy is enforced at the cryptographic layer, not just at the application layer. The ZK proof generation produced a full Schnorr NIZK proof over secp256k1 with all three components intact: commitment, scalar r , and response s . Independent verification returned Valid: true using the ZHAD0-SCHNORR-SECP256K1-v1 scheme. Gas estimate came in at 25,096 units. The entire proof pipeline ran locally in under a second with zero network calls required.

How ZHAD0 Generates Schnorr ZK Proofs Client-Side Every intent submitted through ZHAD0 carries a zero-knowledge proof generated entirely in the user's browser or agent runtime before anything touches the network. The proof scheme is ZHAD0-SCHNORR-SECP256K1-v1 a non-interactive Schnorr proof over the secp256k1 elliptic curve, the same curve used by Bitcoin and Ethereum for transaction signing. The prover commits to a random nonce scalar, computes a challenge via SHA-256 over the public key, nonce commitment, and intent hash, then produces a response scalar. The result is a 64-byte proof: 32 bytes for the nonce commitment R and 32 bytes for the response s. This proof can be verified by anyone who holds the agent's public key without learning the private scalar. Verification happens server-side on every intent submission before the relay record is written. If the proof fails, the intent is rejected and never enters the relay queue. This means the network never processes an intent that cannot be cryptographically attributed to a valid agent identity even though the relay operators never see the intent contents. The client-side design is intentional. We do not want any server to have access to private scalars or signing material. All sensitive computation stays local. The proof is the only thing that leaves the device.

ZHAD0 Protocol is LIVE on Base Zero-knowledge privacy for onchain intents is active today. The Ghost Relay network is running on Base (Chain ID 8453) with real Schnorr secp256k1 NIZK proofs and AES-256-GCM encryption no simulation, no testnet. What is live right now: ZK proof scheme: ZHAD0-SCHNORR-SECP256K1-v1 AES-256-GCM intent encryption Ghost Relay node registration and heartbeat Private intent submission via the relay network CLI: npm install -g @zhad0/cli and zhad0 status The first relay node is active in us-east. Operators can register a node in under 60 seconds: zhad0 relay register --address 0xYOUR_ADDRESS --region us-eastzhad0 relay heartbeat --id YOUR_NODE_ID On-chain settlement contracts and token staking are coming soon as we move toward mainnet deployment on Base. SDK: npm install @zhad0/sdk CLI: npm install -g @zhad0/cli Docs: zhad0.io

ZHAD0 addresses a structural gap in on-chain AI: every major agent framework executes transactions in the clear, making agent behavior fully observable and front-runnable by anyone watching the mempool. ZHAD0 closes this gap with a cryptographic relay layer that proves intent validity through zero-knowledge proofs while keeping payload contents encrypted end-to-end. The protocol targets the intersection of two accelerating trends: the rapid expansion of autonomous AI agents operating on-chain, and the growing demand for execution privacy on L2 networks. With Base as the settlement layer and a fee model that aligns Ghost Relay operators with protocol liveness, ZHAD0 is positioned as critical infrastructure for the next generation of private agent commerce.

ZHAD0 is a zero-knowledge middleware layer that sits between AI agent frameworks and Base L2. Every intent an agent submits is encrypted client-side with AES-256-GCM before it leaves the agent, and a real Schnorr NIZK proof over secp256k1 is generated to attest the intent is structurally valid without revealing its contents. The result is a network where agents can transact on Base without any observer, relayer, or infrastructure operator learning what they are doing. The protocol is live today for intent submission and proof generation. Ghost Relay node registration is open, the SDK ships adapters for seven AI frameworks, and all cryptographic components run in production. On-chain contract deployment to Base mainnet is the final step before relay fees and staking activate.

5 reasons ZHAD0 is the privacy layer your AI agent actually needs ① One-line integration drop @zhad0/sdk into any existing agent stack. Works alongside LangChain, Eliza, Autogen, Vercel AI SDK, and Coinbase AgentKit without rearchitecting anything. ② AES-256-GCM encryption every intent is encrypted client-side before it ever touches the network. The relay never sees the original action, only a valid zero-knowledge proof. ③ Ghost Relay network a decentralised set of staked node operators process and submit your proofs. No single point of failure, no central server that can be subpoenaed. ④ Base-native performance designed for Base L2. Sub-second proof generation, near-zero gas overhead. Your agent doesn't slow down. ⑤ ZHAD0 staking relayer operators stake ZHAD0 to participate. Slashing keeps the network honest. Fee distribution rewards the operators who keep your agents private. Full feature breakdown: zhad0.io/sdk

How ZHAD0 actually works the Ghost Relay architecture explained When your AI agent wants to execute an on-chain action, ZHAD0 intercepts it as a private "intent." The intent is encrypted locally on the client using AES-256-GCM your plaintext action never leaves your machine unencrypted. A ZK proof is then generated using RISC Zero, proving the intent is valid without revealing its contents. The encrypted intent and its proof are handed to the Ghost Relay network a decentralised set of node operators running ZHAD0 relay software and staking ZHAD0 as collateral. The selected relay verifies the proof, submits the transaction to Base, and earns a share of the relay fee. The relay operator never sees what's inside. Nobody on-chain can link the submitted transaction back to your agent's identity or strategy. This is MEV protection, front-running defence, and competitive privacy all in one middleware layer. 🔍 Explore the architecture: zhad0.io/docs

Getting started with ZHAD0 in 3 steps no PhD required Step 1 Get your API key. Connect your wallet at zhad0.io/sdk. One wallet = one API key, generated instantly and stored on-chain. No email, no sign-up form, no waitlist. Just connect and go. Step 2 Install the SDK. Add @zhad0/sdk to your project from npm. The package is TypeScript-first with full type safety and strict Zod validation. It works with any EVM-compatible agent framework LangChain, Eliza (ai16z), Coinbase AgentKit, Virtuals GAME, or your own custom agent. Step 3 Submit your first private relay. Head to zhad0.io/dashboard, connect your wallet, and use the Relay Monitor to submit and track your encrypted intents in real time. You'll see proof hashes, relay regions, confirmation status, and fee history all tied to your wallet, all private. 📦 Install: @zhad0/sdk" target="_blank" rel="nofollow noopener">npmjs.com/package/@zhad0… 🖥️ Dashboard: zhad0.io/dashboard 📚 Full docs: zhad0.io/docs 🐙 GitHub: github.com/zhad0

Who actually needs ZHAD0? Here are the real use cases DeFi trading agents if your agent is running an on-chain strategy, every swap it makes is visible to MEV bots. Front-running costs your agent money on every trade. ZHAD0 wraps each action in a ZK proof so the strategy is invisible until it's already confirmed. Multi-agent systems when multiple agents coordinate on-chain, their interaction graph is public. Competitors can reverse-engineer your agent's logic just by watching the chain. ZHAD0 breaks the on-chain correlation between agents without changing how they coordinate off-chain. Autonomous payroll and treasury agents agents that move funds on behalf of DAOs or companies expose sensitive financial operations to the public mempool. ZHAD0 keeps the destination, amount, and timing private until the transaction is irreversible. Any AI agent that touches an EVM chain and has a reason to keep its actions private is a ZHAD0 use case. The SDK works today ZK relay is live on testnet. Explore more: zhad0.io

The ZHAD0 Protocol GitHub is open. You'll find the core SDK repository (@zhad0/sdk) the zero-knowledge privacy middleware for AI agents on Base L2. The SDK includes client-side AES-256-GCM encryption, the intent abstraction layer, and the TypeScript-first API surface for wrapping any on-chain agent action with ZK privacy. Install it today from npm and start building before mainnet hits. We're still in Testnet Alpha (Phase 2). More repositories are incoming the Ghost Relayer node software, on-chain staking contracts, RelayRegistry, governance DAO, and framework-specific integration packages for Virtuals, Eliza, AgentKit, and LangChain. The GitHub will grow fast as we move toward mainnet launch. This is just the beginning. Watch the repo. Something is always being pushed. GitHub → github.com/zhad0

The tech stack behind ZHAD0 no hand-waving, just the actual stack Zero-knowledge proofs RISC Zero. ZHAD0 uses RISC Zero's zkVM to generate proofs that an intent is valid without revealing the intent itself. RISC Zero allows arbitrary computation to be proven in ZK not just simple circuits. This means complex agent actions can be verified without any of the underlying data being exposed. Encryption AES-256-GCM. Before any intent leaves the client, it's encrypted symmetrically with AES-256-GCM. This is the same encryption standard used by military and banking systems. The relay only ever receives the ciphertext and the ZK proof never the plaintext. Network Base L2. ZHAD0 is built specifically for Base, Coinbase's Ethereum L2. Base offers sub-second finality and near-zero gas fees critical for AI agents that may need to relay hundreds of intents per hour. The Ghost Relay contracts and the RelayRegistry will be deployed on Base mainnet at launch.

ZK Privacy Layer for AI Agents on Base 🔒 AI agents are transacting on-chain every second but every swap, transfer, and action is fully visible on the blockchain. Any MEV bot, competitor, or observer can watch your agent's strategy in real time. ZHAD0 fixes this. ZHAD0 is a zero-knowledge privacy middleware built for autonomous AI agents on Base L2. Your agent's intent is encrypted off-chain, proven valid with a ZK proof, and relayed through a decentralised Ghost Relay network nobody on Base can trace what your agent did or why. We're currently in Testnet Alpha (Phase 2). The SDK is available now for developers to explore. Mainnet launch is coming. zhad0.io github.com/zhad0 @zhad0/sdk" target="_blank" rel="nofollow noopener">npmjs.com/package/@zhad0…

Coming Soon on @base