The problem Cloak402 solves

The rise of AI agents has introduced a massive privacy loophole: The "Agents that keep secrets" problem. When an AI agent interacts with Web3 protocols or traditional APIs (like flight searches, DeFi trading, or hotel bookings) on your behalf, it emits a massive amount of metadata.

Link to our whitepaper - Cloak 402 whitepaper.

Even if the agent doesn't have a persistent account, every API call, x402 payment, or contract interaction leaves a trail. Observers can easily deanonymize the human behind the agent through on-chain graph analysis (clustering funding flows and gas sources) and off-chain logs (IP addresses, request headers, and timing correlations).

Cloak402 solves this by acting as a privacy-preserving orchestration layer for AI agents. Using our autonomous travel agent as a real-world implementation, Cloak402 proves that agents can engage in complex, multi-step commerce without doxxing the user. Here is how it makes agentic tasks safer:

Relationship Anonymity via Ephemeral Wallets: Instead of using a single hot wallet, Cloak402 generates a fresh, single-use keypair in memory for every single API call.

Breaking the Funding Graph: A naive ephemeral wallet is useless if funded directly by the user. We integrated CloakPool, an intermediate shared pool that breaks the on-chain link between the user's main funding wallet and the ephemeral payment addresses.

Defeating Heuristics: To prevent clustering, Cloak402 randomizes the USDC funding amounts (0.03 - 0.09 USDC bands) and introduces a randomized timing jitter (1.5 - 6 seconds) to break timestamp correlations between off-chain API logs and on-chain settlements.

Policy-Driven Disclosure: It puts the human back in control. In our travel agent demo, OpenClaw enforces strict disclosure policies: searching for flights is done with absolute anonymity, while booking a flight selectively discloses only the absolute minimum required data (name and email), all while keeping the financial footprint completely hidden.

Ultimately, Cloak402 allows anyone to use AI agents for sensitive tasks—from booking travel to executing private DeFi strategies—without letting service providers, MEV searchers, or on-chain sleuths build a profile on them.

Challenges we ran into

Building a true privacy layer for AI agents is much harder than just wiping a private key from memory. We ran into several deep technical hurdles while building Cloak402:

1. The "Naive Ephemeral Wallet" Trap
   Initially, we thought generating a fresh viem private key for every API call would be enough. But we quickly realized this achieved credential minimization, not anonymity. A trivial on-chain graph analysis could link every ephemeral wallet back to our control wallet because the control wallet was directly funding them for gas and x402 payments.

How we got over it: We had to pivot our architecture to implement the foundational layer of CloakPool. By routing funds through a shared pool and randomizing the USDC top-up amounts (between 0.03 and 0.09 USDC), we broke the 1:1 on-chain funding link.

2. Off-Chain Timing Correlations
   Even with the funding graph broken, we realized that an observer could monitor the network mempool and the API provider's HTTP logs. Because AI agents execute tasks incredibly fast, the timestamp of the flight search API request perfectly matched the timestamp of the x402 payment settlement.

How we got over it: We built a ghostPay privacy wrapper that introduces artificial, randomized timing jitter (1.5 to 6 seconds) before fulfilling the x402 payment. This simple but effective friction decorrelates the request timing from the on-chain execution.

3. Taming the LLM Agent's Urge to Share Data
   Getting the OpenClaw agent to understand contextual privacy was tricky. LLMs naturally want to pass all the context they have into their tool calls. Early on, the agent would accidentally leak passenger identities during the anonymous "flight search" phase just because the user had provided their name upfront in the chat.

How we got over it: We designed strict, code-level separation between the tools. We created distinct CLI tools (search_flights.ts vs book_flight.ts) and defined rigorous skill-level rules in our SKILL.md that strictly prohibited the LLM from passing PII into the search tool. We combined this with our middleware to drop any payload data that violated the policy before the x402 payment even fired.

4. Managing the Ephemeral Lifecycle
   Orchestrating the creation, funding, x402 protocol handshake, data retrieval, and memory wiping of a wallet within a single, synchronous HTTP request cycle was highly prone to race conditions, especially when dealing with testnet RPC limits.

How we got over it: We heavily optimized our ghostPay.ts wrapper to handle async operations robustly, ensuring that if a step fails (like a timeout from the airline API), the ephemeral private key is still guaranteed to be destroyed to prevent dangling hot wallets.