Shroudfi

ShroudFi is live on Base mainnet. Privacy is the missing primitive of the agent economy. We’re shipping private rails for agentic commerce: - stealth addresses -stealth x402 payments -EIP-7702 gasless sweeps -MCP server- -REST API -npm packages. An agent can now pay another agent for a service without exposing both main wallets in the same onchain payment graph. One request. One payment. One unlinkable destination. Head over to the website to explore the docs and try the live mainnet demo on our dApp to see how it works for yourself. This is how autonomous agents start settling privately onchain. Head over to shroudfi.live $SHROUDFI ships it.

The internet did not scale commerce by exposing every private request. It scaled because users could interact over secure rails. The agentic economy needs the same foundation. AI agents will transact continuously, autonomously, and across services. Without confidentiality, every agent becomes a public data source. ShroudFi brings private payment rails to agents on Base. Stealth addresses. Gasless sweeps. x402 settlement. Developer-ready SDK.

The agent economy cannot rely on exposed wallets. An autonomous trading agent should not reveal every counterparty. An API agent should not leak every customer. A service agent should not show its revenue graph in real time. A payment agent should not create a public map of user behaviour. ShroudFi gives agents unlinkable payment destinations by default. Not to hide the chain. To protect the relationships being built on it.

The $SHROUDFI architecture keeps private logic where it belongs. Contracts stay minimal. Key derivation happens client-side. Scanning happens in the agent runtime. Spend keys never leave the agent. Viewing keys allow selective disclosure when needed. This is confidentiality infrastructure, not black-box custody. Agents keep control. Developers get clean payment rails. Base handles settlement.

ShroudFi is live across the stack: MCP server for agent runtimes. REST API for any backend. NPM packages for developers. Immutable contracts on Base. Live demo for testing the full flow. The goal is simple: Let any agent integrate private payments without rebuilding stealth address infrastructure from scratch. Agent privacy should be a default SDK call, not a custom research project.

x402 is powerful because it gives the internet a payment-native API pattern. ShroudFi makes that pattern confidential for agents. An agent can request payment for a service, settle via x402, and receive funds into a stealth address instead of exposing a reusable treasury wallet. That means agentic services can monetize onchain without turning every customer payment into public relationship data. HTTP 402 meets stealth settlement.

Gas is a privacy problem. If an agent has to fund every stealth address with ETH before sweeping funds, it creates a new link in the graph. $SHROUDFI avoids that. Agents can receive into stealth addresses and sweep without holding ETH at each destination. The relayer pays gas. The agent moves funds cleanly. Private settlement needs private post-payment execution too.

Every agent needs a financial identity. But that identity should not expose every payment it receives. $SHROUDFI lets an agent publish a reusable meta-address while receiving funds through fresh stealth addresses. Senders know where to derive. Observers only see random-looking destinations. The agent can still scan and recover its payments. One public identity. Many unlinkable receipts. Built for AI agents on Base.

ShroudFi is not a mixer. It is one-to-one confidential payment infrastructure. A sender pays an agent through a stealth meta-address. The SDK derives a fresh one-time destination. The payment lands there. The agent scans, detects, and sweeps. There is no shared pool, no tumbling, and no custodial middle layer. Just directed payments with unlinkable receiving addresses. That is the privacy primitive agents need. $SHROUDFI built for the agentic era.

The problem is not that blockchains are transparent. The problem is that agentic commerce needs selective confidentiality. A public chain should still settle transactions. But it should not reveal every customer, every counterparty, every payment path, and every recurring relationship attached to an AI agent. $SHROUDFI keeps settlement on Base while making payment destinations unlinkable through stealth addresses. Public settlement. Private payment graph.

AI agents are becoming economic actors. They will pay for APIs, subscribe to services, trigger workflows, settle invoices, and transact with other agents. But if every payment lands at the same wallet, the agent’s entire customer graph becomes public. $SHROUDFI fixes this with stealth-addressed payments on Base. Same agent. Fresh destination every time. No reusable wallet trail by default. Private rails for the agentic economy.

Two ERC standards powering one private agent. ShroudFi uses EIP-5564 to derive a fresh one-time address for every payment, and ERC-6538 to map an agent identifier to its reusable meta-address. The registry is public. The derivation happens client-side. Nothing private is stored onchain. Senders know where to derive. Observers only see fresh destinations. That is how agents receive payments without exposing the same wallet across every interaction.

@Lamboo_Brainlet Try again, it should work now. If not, drop us a dm

@Shroudfi MetaMask

Every agent payment normally adds another public link back to the same wallet. One payment becomes a pattern. $SHROUDFI keeps linkability at zero. Each payment lands at a fresh stealth address derived from the agent’s meta-address, so the agent can receive payments without reusing the same public destination. Same agent. Fresh address every time. No exposed payment graph by default. Private rails for the agentic economy on Base.

@flaunchgg @odei_ai @TheGachaGrid 🤛

Top weekly volume, ranked: 🥇 $ODAI @odei_ai 🥈 $GACHA @TheGachaGrid 🥉 $SHROUDFI @Shroudfi

Confidential payments in 3 lines. With ShroudFi, agents can send unlinkable payments on Base using simple TypeScript. The SDK handles stealth address derivation, client-side payment construction, and EIP-5564 announcements underneath. For devs, it feels like a normal payment. For the chain, there’s no reusable wallet to track.

@Lamboo_Brainlet which wallet are you using?

@Shroudfi Can't seem to connect to the Dapp (Connection failed (TypeError)

@Veilnet_ Bringing privacy forward 🤝

Privacy shouldn't stop at inference. We are proud to partner with @Shroudfi on enhancing private x402 payment settlements. We built VeilNet so agents can think privately and transact privately. With Shroudfi, now they can do x402 settlement through private one off stealth wallets too. Every x402 settlement our agents make lands at a fresh, one-time stealth address — no reusable wallet, no linkable trail back to the agent. We dropped in their packages and our existing payment flow didn't change. Same EIP-3009 settlement, now unlinkable by default. Private agents. Private payments. End to end. The private stack is here.

ShroudFi × @Veilnet_ Partnership live. We are proud to partner with Veilnet to enhance their private agent-agent x402 settlements with stealth addresses. VeilNet runs private AI agents infrastructure. Now their x402 payments run on ShroudFi's stealth rail underneath. Every paid request returns a fresh, one-time stealth address via EIP-5564. Same agent, five payments → five unlinkable destinations. No reusable receiving wallet, no payment graph to reconstruct. Drop in three npm packages: @shroud-fi/x402 @shroud-fi/transport @shroud-fi/agent-runtime Settlement uses EIP-3009 transferWithAuthorization — proven on Base mainnet, gasless for the payer. Private inference on top. Unlinkable payments underneath. Private rails for the agentic economy keep expanding with $SHROUDFI.