FIDES is live on Robinhood Chain via Pons. Build complete agent transaction flows across MCP, x402 and onchain actions, with authorization built into the execution path. - owner sets budget, assets, contracts, services, limits and expiry, and signs once - agent actions are built into one execution plan - every action is checked against the signed FIDES before it runs - compatible calls and payments are grouped - only the required transactions go onchain agent workflow → FIDES Builder → group + verify → execute contracts deployed and source-verified on mainnet. app, SDK, CLI, API and Claude extension available now. fidesbuilder.xyz OFFICIAL CA : 0x44114d6f66202a267b92bdbb57ae81480a86f0b3

release 03 is loading. the packages just went out on npm: ◈ @fidesbuild/router 0.2.0 (new) ◈ @fidesbuild/swap 0.2.1 ◈ @fidesbuild/sdk 0.2.4 ◈ @fidesbuild/mcp-server 0.8.2 FIDES ROUTER is the headline. right now most agents do a job the first way they find. the first route, the first price. if it's worse, or it fails, they find out after. the router changes that. an agent hands over every way it could do the job, and: ◈ each one becomes its own plan ◈ every action is checked against the FIDES you signed. one action outside the limits and the whole route is out ◈ every survivor is simulated against the live chain, measuring gas and what it really spends ◈ they're ranked: best output → least spent → fewest transactions → least gas → least risk ◈ only the winner runs. nothing valid, nothing runs every route that loses comes with the reason why. the rest of the drop sets it up: → swap 0.2.1: Uniswap quotes per pool, v2, v3 or v4, so the router has real routes to compare → sdk 0.2.4: npm run route in the starter. one swap, every Uniswap pool, only the best runs → mcp-server 0.8.2: the Claude server, packaged fresh packages are out. the full release is close behind, with it running live on mainnet. npmjs.com/package/@fidesbuil… npx @fidesbuild/router if you want an early look. 03 FIDES ROUTER. soon.

most agents do a job one way. the first route they find, the first price they're given. if it's worse, fails, or costs double the gas, they find out after it's sent. FIDES ROUTER changes that. the agent hands it every candidate route for the same job. the router runs each one through the full FIDES pipeline before a single transaction goes out: 1. build every candidate becomes its own execution plan. a route that can't build is out: UNKNOWN_DEPENDENCY 2. check every action of every route against the signed FIDES. a route is authorized as a whole or not at all. one action outside the limits and the entire route is discarded: - SPEND_LIMIT_EXCEEDED - SELECTOR_NOT_ALLOWED - TARGET_NOT_ALLOWED no half-routes, ever 3. floor each route can carry its expected output and a minimum. expected below the minimum → out 4. simulate every surviving route against the live chain: - fails → out, with the revert reason - gas measured per route - real token outflow measured per asset, from the simulation, not the quote 5. rank best output → least spent → fewest transactions → least gas → least risk risk = steps that can fail without reverting, plus offchain calls and x402 payments slippage scored against the best quote in the set, in basis points or plug in your own ranking 6. execute only the winner. one signature, same FIDES Account, same budget, same expiry. nothing valid → nothing runs: NO_VALID_ROUTE example, five routes for one payment: ✗ overspend SPEND_LIMIT_EXCEEDED ✗ forbidden-call SELECTOR_NOT_ALLOWED ✗ malformed UNKNOWN_DEPENDENCY ✓ two-hop 24 out, more gas ✓ direct 20 out, less gas ← executed only the chosen route touched the chain. every loser comes with the reason it lost. the router chooses inside the line you signed. it never crosses it. release 03. tonight.

release 03 drops tonight. so far, FIDES decides what an agent is allowed to do. tonight it starts deciding how it should do it. FIDES ROUTER. evening.

everyone's building agents. almost nobody is building the part where the agent touches money. right now it's two options: - give it a key and pray - approve every transaction yourself and lose the point of an agent FIDES is the third option. you sign the limits once: - how much it can spend - which contracts, which functions - which APIs and MCP tools, with caps - what it can trade, at what worst price - when it all expires then the agent runs. Uniswap, Morpho, any verified contract, any x402 API. inside the line, it's free. outside it, blocked before anything is sent. not a dashboard. not a promise. a signature the chain checks. Claude: install the extension, say "set up FIDES" SDK: npx @fidesbuild/sdk init fidesbuilder.xyz

picture this. monday morning you sign one thing. 50 USDG, three contracts, two paid APIs, until friday. then you close the laptop. 09:12 your agent buys market data from an API. 0.04 USDG. it read the price before it paid. 11:40 idle USDG is sitting there. it lends it out. approves exactly the amount, nothing left approved. 14:03 it wants ETH. checks Uniswap, the price is outside what you allowed. it waits. 14:51 price is back inside. it swaps. 16:20 a prompt-injected webpage tells it to send everything to some address. it tries. blocked. that function was never in what you signed. 18:00 it hands a smaller agent 5 USDG for a research job. the child can't spend a cent more. friday it all just stops. nothing left to revoke, nothing left approved. you never woke up to a surprise. you never approved a single transaction. and the agent never once did something you didn't say it could. that's the whole thing. not smarter agents. agents you can actually leave alone with money. that's FIDES. tomorrow, it gets smarter about how it does the job too.

FIDES as of today. what your agent can actually do, inside limits you sign: - trade on Uniswap "swap 0.05 USDG for ETH" best route across every pool, v4 hooks included. checked against your mandate, simulated, exact approval, nothing left approved - lend on Morpho “supply 0.01 USDG to the USDe/USDG market" supply and withdraw allowed. borrow never - use any verified contract on Robinhood Chain paste the address. FIDES reads the code, flags the risky functions, you tick the rest - pay any x402 API on the chain paste the URL. price read before a cent moves. capped per service - read anything for free markets, balances, positions. no permission needed, nothing sent - hand out SUB-FIDES give another agent a slice of your budget. it can never exceed yours - settle with FIDES NET net what's owed across services, settle once one signature covers all of it. app, Claude, SDK, API. fidesbuilder.xyz

this is exactly why we built connect anything. stock tokens as collateral on Morpho means Robinhood Chain now has real credit markets, and agents are going to want to use them. the hard part was never reaching Morpho. it's letting an agent near credit markets without handing it the keys to your money. that's FIDES. paste Morpho's address, FIDES reads the verified contract and flags every risky function: borrow creates debt, setAuthorization hands over control. you tick only what you want, say supply and withdraw on a USDG market, and sign once. your agent can then lend into these markets, read positions and pull funds back, by name, in plain words, from Claude, the app or the SDK. every call is checked against what you signed, simulated before it's sent, with exact approvals and nothing left approved. borrow stays blocked unless you choose to allow it. we ran it on mainnet yesterday with real USDG: supplied to a Morpho market on Robinhood Chain, withdrew it, zero approval left behind. credit markets for stock tokens are live. now agents can use them safely. @Morpho fidesbuilder.xyz/docs/#/conn…

what actually happens when a FIDES agent supplies 0.01 USDG to a lending market 1. read the contract's verified source from Sourcify, proxies followed to the real code. the market read onchain, free: 360M USDG supplied, LLTV 91.5% 2. build supply(marketParams, 10000, 0, me, 0x) encoded from the verified ABI. no hand-written calldata, no guessing selectors 3. check every action against the signed FIDES: - target allowed? 0x9D53…1010 ✓ - selector allowed? 0xa99aad89 supply ✓ - budget left? 0.01 of 0.01 ✓ - not expired, not revoked? ✓ borrow (0x50d8cd4b) isn't in the FIDES → blocked: SELECTOR_NOT_ALLOWED 4. bundle approve exactly 10000 + supply → 2 writes, 1 transaction through the FIDES Account. relayer pays gas 5. simulate against the live chain. fails → nothing sent 6. send only when the owner says yes 7. after allowance left: 0 real run, mainnet, real USDG: robinhoodchain.blockscout.co… why this matters: an agent that can touch money is only useful if you can say exactly what it's allowed to do. that's the layer FIDES is. the same 7 steps work for any verified contract on Robinhood Chain. lending was the example. it could be a vault, a DEX, a payment contract, your own protocol. what you can build on it: - treasury agents: idle stablecoins lent out, pulled back when needed, never borrowed against - trading agents: Uniswap swaps inside a signed mandate, worst price and size capped - research agents: pay x402 APIs per request, each one capped, from one budget - agent teams: one FIDES, sliced into SUB-FIDES for each worker agent, none can exceed the parent - apps: give your users agents without ever holding their keys. they sign the limits, the agent runs inside them for builders it's infrastructure, not a product you route around: - SDK: npm i @fidesbuild/sdk. your agent plans, the Builder checks and simulates, the relayer sends - Claude: one extension, plain English, same checks - API: read any contract's functions and risks, price any paid API, relay plans - app: owners sign limits in a few clicks, no code the agent decides what to do. FIDES decides what it's allowed to do. the chain enforces it. this is what "agent with limits" means in practice.

end of the day. here's what FIDES shipped on Monday. this morning: Uniswap × FIDES - agents trade on Uniswap inside a mandate the owner signs: what it can buy, worst price, most per swap - best route across every pool, v4 hooks included - simulated before it's sent, exact approval, nothing left approved - first live swap through Claude landed 0.13% above the quote. it can land above. never below the floor you signed this evening : connect anything - any verified contract on Robinhood Chain. paste the address, FIDES reads it, flags the risky parts, you tick what's allowed - any paid API that charges on the chain. FIDES reads the price before a cent moves - agents call contracts by name. "supply 0.01 USDG to that market", built from the verified code, checked, simulated, then sent - real mainnet run: an agent lent USDG on Morpho and pulled it back. borrow was never possible same boundary across all of it, in the app, in Claude, in the SDK and over the API. one signature. a budget, the contracts and functions allowed, the services and their caps, an expiry. the agent works inside it. everything else is blocked before it's sent. why it matters: the agent meta is moving fast. agents trade, pay for data, call tools, use protocols. the question nobody's answered properly is what they're allowed to do with your money. most setups today are all or nothing. hand over a key, or babysit every transaction. FIDES is the middle: you decide the limits once, sign them, and the agent is free inside them. Uniswap, Morpho, x402, APIs, MCP tools, whatever's next, they all plug into the same signed boundary. one day. two integrations. the whole chain is now reachable for agents, with limits that hold. still more on the roadmap. FIDES ROUTER is next. gn 🌙

major update: FIDES now connects to anything on Robinhood Chain. until today an agent could only use what we'd wired up. now it can use any verified contract and any paid API that charges on the chain, under limits you sign. paste an address or a URL. FIDES reads it, explains it in plain words, you tick what your agent may use. everything else stays blocked. what you can do now: - lend idle budget on Morpho: supply + withdraw allowed, borrow never - use any verified vault, pool or protocol on the chain. same flow, any address - let your agent read any contract for free: markets, balances, positions - plug in any paid x402 API by URL: FIDES reads the price before a cent moves - swap on Uniswap inside a signed trading mandate (live this morning) - and still: paid APIs like spraay (AI models) and madeonsol (KOL feed), and MCP tools allowed one by one, per server any contract: - reads the verified source, follows proxies to the real code - every function that changes something, in plain words - flags what needs a second look: risky: approvals, ownership, upgrades, borrowing check: the agent picks where funds go operators only: will just fail for an agent - agents call it by name: "supply 0.01 USDG to that market". FIDES builds the call from the verified code, checks it against the FIDES, simulates, then asks any paid API: - called once without paying to read its x402 price - shows the price, who's paid, and a suggested cap - if it charges somewhere FIDES can't pay, it tells you why - every request counts against the budget you signed we ran it on mainnet with real USDG: an agent supplied to a Morpho USDG market and withdrew it, approval for the exact amount, nothing left approved after. a borrow? blocked before it's built. where it works: → app: paste on Contracts or Services, tick, sign. then run calls by function name → Claude: "what could my agent do on 0x9D53…1010?" / "supply 0.01 USDG to that market" / "can you use this API: https://…" → SDK: allowed contracts are just targets. same Account, budget and expiry → API: GET /v1/contracts/{address} + POST /v1/services/probe. read-only Uniswap this morning. any contract, any API tonight. agents on Robinhood Chain just got the whole chain. fidesbuilder.xyz/docs/#/conn…

Uniswap × FIDES is live. agents can now trade on Uniswap on Robinhood Chain, inside a trading mandate the owner signs: - what it may buy - the worst price it can ever accept - the most it can move in one swap -the total budget and the expiry most agents that trade today just take the price they're given and hope. a FIDES agent can't. here's a real one, live on mainnet just now: → "set up FIDES with Uniswap swaps: budget 0.1 USDG, buy ETH, max 0.05 per swap, 1% slippage" Claude sends one link. I tick Allow Uniswap swaps, sign once. → "swap 0.05 USDG for ETH" - Uniswap finds the best route across its pools, v4 hooks included - checked against the mandate. outside it, refused before anything is built - simulated first, measuring what would actually arrive - shown to me: quoted, lowest accepted, simulated. nothing sent until I say yes → "yes execute" - approval for exactly 0.05 USDG + the swap, one transaction - relayer paid the gas - nothing left approved - quoted 0.0000215214 ETH, received 0.0000215486. landed 0.13% above the quote it can land above the quote. it can never land below the floor you signed. as far as we can tell, nobody has put agent trading on Uniswap behind a signed mandate like this before. we spent the weekend making sure it holds. live now in the app, in Claude, and in the SDK: npx @fidesbuild/swap fidesbuilder.xyz

first real agent swap on Uniswap through FIDES. Robinhood Chain mainnet. done. npm run swap -- --send here's what actually happened in that one command: - the agent asked to swap more than its mandate allowed. refused before anything was built - then the real one: Uniswap found the best route, a v4 pool with a hook - checked against the mandate the owner signed: ETH only, 1% worst price, 0.1 USDG max per swap - simulated first, measuring exactly what would arrive - approve + swap went out as ONE transaction - quoted 0.0000215084 ETH, received 0.0000215062. inside the price the owner signed - approval left with Uniswap afterwards: none the agent held no funds and paid no gas. the owner signed once. every rule held, live, onchain. as far as we can tell, nobody has done agent trading on Uniswap behind a signed mandate like this before. @Uniswap @RobinhoodApp @vladtenev tx: robinhoodchain.blockscout.co… Uniswap × FIDES. agents that trade, inside limits they can't break. Releasing today. Testing going great so far. npm i @fidesbuild/sdk

FIDES - Two Major Releases Today! New week, and we’re starting it with two technical releases. 03 / Uniswap × FIDES After a weekend of development, we’re preparing to launch autonomous swap execution through Uniswap. Agents will be able to trade within owner-signed mandates, with spending budgets, approved assets, price limits and expiry enforced through the FIDES Transaction Builder. 04 / New Integrations - Later Today Our second release expands what FIDES can connect to, opening up new execution capabilities for autonomous agents. We’re keeping the details under wraps until the announcement. With FIDES NET and SUB-FIDES already live, today’s releases mark another step in expanding our execution infrastructure. Two releases. One day. More working tech. Big day ahead. 🌐 fidesbuilder.xyz

agents are getting good at deciding what to do. the hard part is everything after the decision. which calls, which payments, in what order, with whose money, inside whose limits. that's the layer FIDES is built for. the owner signs the limits once. the agent plans, the Builder checks every action against what was signed, groups what can go together, and only what's allowed reaches the chain. Agent workflow → FIDES Builder → Group + Verify → Execute

end of the weekend. good one. we spent it building, not posting. two things are ready to ship tomorrow: - Uniswap × FIDES. agents trading inside a mandate the owner signs - a big step for what you can connect a FIDES to. more on that tomorrow where the roadmap goes after that: - 03 · FIDES ROUTER. the Builder generates several ways to do the same job, simulates them all, and runs the cheapest valid one integrated along with the Uniswap x Fides update but more. - 04 · LONG FIDES. recurring execution, with daily or weekly budgets that reset and a hard expiry over the top - 05 · SERVICE MANIFESTS. services describe what they do and what they cost, so the Builder can find and plan paths on its own - 06 · PRIVATE FIDES. budgets and strategy stay private, with proof that execution stayed inside the limits - 07 · FIDES PROOF. a proof that an agent followed its mandate, checkable without trusting us NET and SUB-FIDES are already live. tomorrow adds trading and a lot more reach. big week. see you in the morning.

been thinking a lot about what an owner should actually sign before an agent touches Uniswap. not "here's my wallet, go". something closer to a mandate a fund gives a trader: - what it may buy, say ETH - the worst price it can accept, say 1% below the quote - the most it can move in one swap, say 2 USDG - the total budget, say 10 USDG - when it ends, say 24 hours inside those lines the agent trades freely. outside them, nothing goes out. when the budget's gone, it stops. at expiry, it stops. revoke it and it stops on the next call. no standing approvals, no blank cheques, no "trust the bot". that's the shape of what we're wiring into FIDES with @Uniswap recent v4 aggregator update.

first thing we had to figure out for Uniswap × FIDES: a swap isn't like a transfer. with a transfer the agent knows exactly what leaves. with a swap, what comes back depends on the route and the price at that moment. so FIDES has to check both sides before anything is signed: - what leaves: inside the budget - what arrives: a token you allowed, at a price you'd accept best route from Uniswap. both sides checked by FIDES. shipping soon.

late one. the boring part of agent infra is the part that matters. not the model, not the prompt. it's what happens between "the agent decided" and "the chain executed". that's where FIDES sits. every action gets checked against what the owner signed, compatible ones get grouped, and only the transactions that are needed go out. anything outside the limits never leaves the builder. Agent workflow → FIDES Builder → Group + Verify → Execute still building. more soon.

small one, but it matters. creating a FIDES used to mean knowing contract addresses, function selectors and service names off by heart. most people don't. we didn't expect them to. so now the app just shows you the options. need USDG transfers? one click. want your agent buying live chain data, AI model lists or a trade feed? pick it, the price is right there, the cap's already set. giving it an MCP server? the safe tools come listed. read and search, never write or delete. click what you need, sign once, done. same on the agent side. you don't have to fill anything in yourself: - claude: ask it to set up FIDES and it already knows the paid APIs and what they cost. it sends you a link with everything filled in, you set the budget and sign - sdk: npx @fidesbuild/sdk init prints a link with everything the examples use already ticked. sign it, fund it, npm start the agent picks up the FIDES on its own once it's signed. no copying files around. more integrations on the way.

"You can't stop it" is only true if the agent has the keys. Most agent setups today give the agent a wallet, a private key or an open approval, and then hope it behaves. Then the agent makes a call nobody signed off on and the money is already gone, because nothing between the agent and the chain was checking anything. That isn't an AI problem. It's an authorization problem, and it's the one we've been building FIDES to solve. With FIDES the agent never holds the money. Funds sit in a FIDES Account, a contract only the owner controls. The owner signs one FIDES that sets the budget, the tokens, the contracts and functions the agent may call, the services it can pay, an action limit and an expiry. Every action the agent plans is checked against that signature before anything is built. Anything outside it is blocked and never sent. The contract checks it again on every execution, and spend is tracked onchain across every transaction, so the budget can't be split up and drained. The agent's key holds no funds and needs no gas. If the agent is compromised or goes off script, the most it can do is what the owner already signed. The owner can revoke it with one transaction and it stops on the next call. - Owner signs the limits once, as EIP-712 - Agent workflow → FIDES Builder → Group + Verify → Execute - Every action is checked against the signed FIDES before execution - Blocked actions are never sent onchain - Budget enforced by the contract, cumulative, not per transaction - SUB-FIDES: an agent can hand a slice to another agent, and the child can never exceed the parent - Revoke at any time; it stops at the next execution You can stop it. You just have to build the stop into the execution path, not bolt it on after. @vladtenev @RobinhoodCrypto