Barker: Autonomous Stablecoin Yield Execution on the Portals API

Barker is a platform that maps where idle stablecoins can earn across DeFi and CeFi, and routes capital into those opportunities, with 40,000+ users and $7M+ routed through the platform.

But Barker's ambition points past dashboards. It's building to be the yield primitive for the agent economy, the default layer any AI agent calls to put idle stablecoins to work. To turn this ambition into reality, Barker integrated the Portals API.

How Barker Autonomous Stablecoin Yield Execution on the Portals API Works

A user, or an autonomous agent, finds a stablecoin yield opportunity on Barker and deposits into it in a single click, powered by the Portals API behind Barker's protocol pages and agent wallet.

Portals handles the execution: building the deposit route and bundling it into one transaction. Before that transaction is signed, Barker simulates it with Foresight and shows the user exactly what it will do.

Why Barker Didn't Build Execution In-House

Building and maintaining the execution layer underneath, routing a deposit into every one of those opportunities, across protocols and chains, is a different problem and a large one.

Rather than spend engineering time wiring up per-protocol deposit paths, Barker composes the Portals API and inherits execution coverage across the DeFi surface it already maps. One API call turns a mapped opportunity into an executable deposit.

Pre-Sign Preview: Two Products, One Modal

Barker's deposit modal is split between two Portals products, and the split shows exactly what each one does.

The top half is the Zaps API. It takes whatever asset the user holds, builds the route into the target vault, and returns the terms: estimated amount received, cost, the route itself (Approve → Deposit), and slippage tolerance.

The bottom half is Foresight. Labelled Pre-Sign Preview, it simulates the assembled transaction and reports what will actually happen: the precise amount that will be received, the exact amount spent, estimated gas, and a status verdict on whether the transaction will succeed.

The difference between the two halves is the point:The Zap estimate reads ≈2.1308 vault shares. The Foresight preview reads 2.130842408328683072. Not a projection but the simulated outcome of the transaction as assembled, alongside the gas it will consume and a "Likely to succeed" status.

One product builds the transaction; the other verifies it. The user sees both before they sign anything.

The Agent-Economy Angle

Barker is built agent-native, and this is where the Portals integration does something most yield platforms can't. Barker exposes an open MCP interface so AI agents can call its yield data and routing directly.

It's a first-batch ASP on the OKX AI marketplace, and it's wired into three x402 agent-payment rails, OKX, Coinbase, and Circle, so agents pay per call, atomically, with funds settled on-chain.

A user simply tells the agent what they want, for example, to deposit USDC into a Steakhouse High Yield vault (Morpho V2) on Base using their agent wallet. The agent checks Barker's real-time yield data, confirms the target vault and chain, prepares the deposit, and routes it through Portals.

Execution runs through Barker's managed agent wallet: it signs and broadcasts approve and deposit on the user's behalf, with no browser-wallet signature required at any step. The user never touches a DeFi interface, chooses a route, or assembles a transaction. They express intent; Portals handles it.

This is the full agent loop in production: intent (natural language) → discovery → simulation → execution, running end to end.

In a live run, the agent completed a USDC deposit into a Morpho V2 vault on Base entirely through Portals, from a single typed request to an on-chain transaction. It maps directly onto where both teams see DeFi heading, an agent economy where software, not people, moves idle capital to the best yield. See the attached video below.

How It Works

1. Discover. A user tells the agent what they want in plain language, or an agent calls Barker's data directly, to find a stablecoin yield opportunity.
2. Confirm. The agent checks Barker's real-time yield data and confirms the target vault, chain, and amount.
3. Zap (Portals). Portals builds the deposit route and bundles approve and deposit into a single transaction.
4. Verify (Foresight). The assembled transaction is simulated before signing: exact amounts, gas, and whether it will succeed.
5. Execute. Barker's managed agent wallet signs and broadcasts on-chain, no browser-wallet signature needed. The deposit lands in the target vault.

Integration at a Glance

• Products used: Portals Zaps API (routing and execution) and Foresight (pre-sign simulation).
• Live deposits: USDC → Aave V3 on Arbitrum; USDC → Steakhouse High Yield / Morpho V2 on Base; AUSD → Flowdesk AUSD RWA Strategy (Morpho V2) on Ethereum. All routed through Portals, all on-chain.
• Surfaces: Barker's protocol pages and its conversational agent wallet.
• Agent access: open MCP interface, OKX AI marketplace (first-batch ASP), x402 payment rails (OKX / Coinbase / Circle).

Building an app, or an agent, that moves capital into DeFi yield? Barker runs on two Portals products you can use together: the Zaps API to execute one-click deposits, and Foresight to simulate them before anyone signs.