TL;DR
By 2027, the majority of crosschain volume will be initiated by software, not people: autonomous agents, solver bots, treasury automation, and consumer apps abstracting the bridge away entirely.
An agent-native bridge has to satisfy five constraints: one deterministic API call, no claim transactions, programmatic deposit options for non-signing flows, composable destination actions, and machine-readable docs. Most bridges still don't.
Across' agent stack is in production today: the Swap API, the Skills CLI, the MCP Server (seven structured tools), ERC-7683 support, counterfactual deposit addresses, and the MulticallHandler for atomic bridge+action.
The bridge isn't a destination anymore. It's a function call the agent makes, and the protocols built for that shift will be the ones that compose into the agent-native future cleanly.
For most of crypto's history, every onchain action started with a human clicking a button. Connect wallet, approve token, sign transaction, wait, repeat. The bridge UI was designed for that human, and so was the support documentation, the error message, the recovery flow.
That assumption is going to age very poorly. By 2027, the majority of crosschain volume will be initiated by software, not people. Autonomous agents rebalancing portfolios, market makers chasing yield across chains, treasury bots distributing protocol funds, consumer apps abstracting bridges out of sight. None of these read a UI. None of them tolerate a multi-step claim flow. They need infrastructure that was built for them, not retrofitted around them.
This is the case for what that infrastructure looks like, why most bridges aren't ready for it, and what the agent-native crosschain stack already has in production today.
The Volume Shift Is Already Underway
Three trends are converging.
Onchain trading volume is increasingly executed by automated systems. Solver-based DEX architectures, MEV searchers, intent-fillers, and structured-product rebalancers all run as software. None of them are clicking through Uniswap. The same people building those systems are now building the layer above them: agents that decide when and where to deploy capital, not just how to execute a single trade.
AI coding tools went from novelty to default in 18 months. Claude Code, Cursor, Codex, Windsurf, and Copilot are now how a meaningful share of crypto developers ship. Those tools have direct access to Across via the Skills CLI and the MCP server, which means a developer asking an AI assistant to "bridge 1,000 USDC from Arbitrum to Base" can have it executed end-to-end without writing the code themselves. The bridge isn't a destination they navigate to. It's a function call the assistant makes.
Consumer apps are abstracting bridges away entirely. Wallets, DEX aggregators, and portfolio dashboards are increasingly hiding the bridge behind a "send" button or a yield strategy or a one-click rebalance. The user doesn't know they're bridging. The app's backend does, and the app's backend is software making API calls.
The throughput of all three combined will, before 2027, exceed the volume of humans bridging tokens by hand. The infrastructure that catches that wave will be the infrastructure that was designed for it.
What's Already Live
The agent-native stack on Across is not a roadmap item. It's in production today.
The Swap API. A single REST endpoint at /swap/approval that returns calldata for any route across 23+ supported chains. Trade types include exactInput, minOutput, and exactOutput. Settlement mechanism selection is automatic. Documented at docs.across.to.
The Skills CLI. One command (npx skills add https://github.com/across-protocol/skills --yes) drops bridging tools into Claude Code, Codex, Cursor, and Openclaw. After installation, the AI assistant can fetch quotes, build transactions, execute approvals, and track fills via natural language.
The MCP Server. Hosted at https://mcp.across.to/mcp and compatible with Claude Desktop, Claude Code, Cursor, VS Code Copilot, Windsurf, and Codex. Exposes seven tools for documentation search, page fetching, API reference, supported-chain queries, live fee lookups, code examples, and forced doc refresh.
ERC-7683. Across implements the crosschain intent standard, defining a common order format for intent-based systems. For agents that target multiple intent protocols, this means a shared order schema works across implementations.
Embedded crosschain actions. Through the MulticallHandler contract, agents can attach arbitrary destination-chain calls to a bridge. The pattern is documented and the contract is deployed across every supported chain.
The infrastructure exists. What's missing is breadth of agent adoption, and that gap closes quickly when the first wave of agent-native applications proves out the model.
What to Build Right Now
For developers shipping today, the practical takeaways are concrete.
If you're building an agent that touches DeFi across multiple chains, integrate the Swap API directly and structure your prompts so the agent calls it cleanly. Add the Skills CLI to your coding environment so your AI assistant can construct and execute bridge calls during development.
If you're building a consumer app that wants to abstract bridges away, the MulticallHandler is the primitive that lets you bundle bridge + action without exposing the bridge to the user. Make the action the product. Make the bridge invisible.
If you're running infrastructure that holds funds without keys (bots, automation, CEX onramps), the counterfactual deposit address flow is what you want to study first. It's the primitive that decouples bridging from wallet signing.
Start at docs.across.to. The agent-native infrastructure is already in production. The bridges that are easy for software to use will outlast the ones that aren't.