Ophis MCP

Ophis

Choose tokens, review the quote, and authorize your swap.

An intent-based DEX aggregator with a natural-language layer, built for humans and agents alike.

Swap App · Docs · Explorer · Agents · SDK · Security

Select tokens and networks in the swap app, review the quote, and authorize the displayed flow. The optional Intent API parses requests such as swap 100 USDC for ETH on Base; it does not execute them. Batch-auction orders settle onchain through configured solver routes. It is a fork of CoW Protocol (orderbook, autopilot, driver, and baseline solver) with a natural-language intent layer over a rebranded CoW Swap UI. On Optimism, Unichain, Robinhood Chain, and Arc, Ophis runs the whole stack under its own settlement contracts and keeps the full fee; on the other supported chains (Ethereum, Base, Arbitrum, and more) it routes through CoW Protocol's hosted network.

For standard batch-auction orders:

• Gasless, MEV-protected. Orders settle in a batch auction where every trade uses uniform prices per token pair. Offchain submission and signed limits mitigate common MEV; they do not eliminate every execution risk.
• Solver-aligned pricing. On every supported chain the base fee is 1 bp. Ophis also earns when execution beats its reference quote: 80% of improvement on volatile pairs (99 bps cap), or 50% on stable pairs (20 bps cap). Hosted chains encode that policy in CIP-75 appData and separately pay CoW Protocol's upstream fees.
• Non-custodial, no account, no auth. Every order is signed in your own wallet (EIP-712 or ERC-1271), or explicitly presigned onchain. Standard ERC-20 orders keep funds in the wallet until settlement; native-token, bridge and external OTC flows can require deposits and have separate recovery rules.
• Transparent, capped fees. A 0.01% (1 bp) base plus the capped improvement policy above.

Live across 14 EVM chains, with Ophis-operated settlement on Optimism (chain 10), Unichain (130), Robinhood Chain (4663), and Arc (5042), plus CoW-hosted settlement on the other ten chains. Arc applies the same capped backend improvement policy for in-market orders; settled trades are indexed for routed volume and referral attribution.

Quickstart: the Intent API

Ophis's one bespoke API turns natural language into a structured order. No key, no account, just POST your request:

curl -sS https://ophis.fi/api/intent \
  -H 'content-type: application/json' \
  -d '{"text":"swap 100 USDC for ETH on Base"}'

{
  "ok": true,
  "data": {
    "intent": "swap",
    "entities": [
      { "type": "amount",    "value": "100",  "raw": "100",  "start": 5,  "end": 8 },
      { "type": "sellToken", "value": "USDC", "raw": "USDC", "start": 9,  "end": 13 },
      { "type": "buyToken",  "value": "ETH",  "raw": "ETH",  "start": 18, "end": 21 },
      { "type": "chain",     "value": "base", "raw": "Base", "start": 25, "end": 29 }
    ]
  }
}

Map the chain slug to a chain ID and hand the user a swap deep link to review and sign. The endpoint only normalizes text, it never places, signs, or executes a trade. It is rate-limited to 30 requests per minute per IP; non-browser callers (no Origin header) are allowed, which is the path agents use. Full reference: docs.ophis.fi/intent-api.

Agents and SDK

Ophis is built to be traded by autonomous agents, not just people. Pick your integration depth, all of it non-custodial and keyless:

MCP server (recommended)

Point any MCP client (Claude, Cursor, a custom agent) at the hosted Model Context Protocol server:

https://mcp.ophis.fi/mcp

It speaks Streamable-HTTP MCP and exposes 13 tools: intent parsing, canonical token resolution, chain discovery, quoting, bounded order build/validation and submission, integrator volume and fee lookups, balances, portfolios, gas, charts, and expected-surplus comparison. The server holds no keys and never signs. build_order returns a bounded, ready-to-sign EIP-712 order with the receiver pinned to the owner; the agent signs locally with its own key and submits. See the complete tool reference. (A bare request without an Accept: text/event-stream header returns HTTP 406, that is the transport negotiating, not an outage.)

@ophis/sdk

For agents that build and sign CoW orders directly:

npm install @ophis/sdk

The SDK encodes four fork details that fail silently if you guess them:

• getOphisOrderbookUrl(chainId) picks the right host. Optimism self-hosts its orderbook (not api.cow.fi); the wrong host bypasses the Ophis solver and zeroes the fee.
• getOphisOrderDomain(chainId) gives the EIP-712 domain with the correct verifyingContract. The OP settlement is non-canonical, so the cow-sdk default is rejected on-chain.
• buildOphisAppDataPartnerFee(chainId) builds the exact CIP-75 volume-fee fragment { volumeBps, recipient }, not the price-improvement shape.
• assertReceiverIsOwner(owner, receiver) pins the order receiver. An unpinned receiver is the number one drain vector for an automated signer.

Discovery and the trust boundary

Ophis publishes machine-readable manifests for agent discovery under https://ophis.fi/.well-known/: mcp.json, ai-plugin.json, agent-skills/, and api-catalog (RFC 9727), plus the root-served auth.md, llms.txt, and openapi.json.

These off-chain helpers make the safe path the easy path, but they are guards, not an authorization boundary: a prompt-injected agent can ignore them. For an agent that signs without a human in the loop, enforce policy where the agent cannot reach it: funds in a Safe smart account, a deterministic policy gate (allowlisted tokens, pinned receiver and appData, an oracle-bounded limit price, spend caps), a guardian key, and the same policy checked again at orderbook ingestion. Full guide: docs.ophis.fi/ai-agents.

Status

Ophis settles across two kinds of chains.

Ophis-operated (self-hosted orderbook, solver, and settlement; Ophis keeps the full fee):

CoW-hosted (orders route through CoW Protocol's settlement and solver network, with the partner fee disbursed by CoW): Ethereum, Base, Arbitrum, Polygon, BNB, Gnosis, Avalanche, Linea, and the other CoW-supported chains, all live.

On BNB Smart Chain (BSC, chain ID 56) Ophis is live: orders placed through Ophis (SupportedChainId.BNB in cowSdk.ts, mapped from the bnb slug in chainMap.ts) settle on-chain through CoW Protocol's GPv2Settlement at 0x9008D19f58AAbD9eD0D60971565AA8510560ab41 on BSC, giving gasless, MEV-protected swaps with no Ophis-side custody. Ophis does not deploy its own settlement on BSC; BNB trades use CoW Protocol's canonical BSC deployment.

The two have different settlement contracts and orderbook hosts, so resolve them per chain via @ophis/sdk or the MCP list_chains tool rather than assuming. Full live status: docs.ophis.fi/status. The standalone app also supports Bitcoin, Solana, Monad, Hyperliquid (Hypercore), X Layer, Sui, Tron, Starknet and Zcash as NEAR sources and destinations where live assets and quotes permit. Selecting an external source opens a deposit flow in the same swap form: review the quote and source-chain refund address, confirm, then fund the specified deposit before its deadline with any required memo. This is separate from SDK/MCP EVM order building. See networks and funding coverage. Canonical contract addresses and the disclosure policy live in SECURITY.md.

Architecture

Upstream subtrees are vendored as-is; Ophis changes are catalogued in apps/frontend/.ophis-divergences.md and apps/backend/.ophis-divergences.md so git subtree pull stays tractable.

Repo map

ophis/
├── apps/
│   ├── frontend/        cowswap fork: swap UI + explorer + landing site
│   ├── backend/         cowprotocol/services fork (Rust)
│   ├── rebate-indexer/  trade indexing, routed-volume reports, USDG trade rewards
│   ├── docs-ophis/      Docusaurus docs portal
│   └── mcp-server/      agent-facing MCP Worker (mcp.ophis.fi)
├── contracts/           GPv2 settlement contracts (+ per-network deployments)
├── packages/sdk/        @ophis/sdk
├── packages/cli/        @ophis/cli
├── functions/           Cloudflare Pages Functions (intent API, middleware)
├── infra/               per-chain runtime stacks + rpc + cloudflare config
├── scripts/             repo utility scripts
└── docs/                specs, plans, audits, operations runbooks

Build

Root workspace (pnpm 9, Node 20.19+ or 22.12+, turborepo):

pnpm install      # all root-workspace deps
pnpm build        # builds members with a build step (currently @ophis/sdk)
pnpm typecheck    # typechecks every member
pnpm test         # runs the unit suites

Only packages/sdk has a build step today. apps/rebate-indexer, apps/mcp-server, and infra/rpc run directly (no build script) and are validated by pnpm typecheck and pnpm test. The Rust backend (apps/backend) is a Cargo workspace, not a pnpm package, so build and test it with Cargo:

cd apps/backend && cargo build && cargo test

apps/frontend and apps/docs-ophis are self-contained pnpm workspaces with their own lockfiles, deliberately excluded from the root. Build them from inside their own directory (see each app's README):

cd apps/frontend   && pnpm install --frozen-lockfile && pnpm run build:cowswap
cd apps/docs-ophis && pnpm install --frozen-lockfile && pnpm run build

The contracts use Foundry (forge build); forge-std is a git submodule, so run git submodule update --init first.

Deploy

Every surface deploys independently from main:

• Swap app and Explorer cloudflare-deploy.yml: two sequential Cloudflare Pages deploys (swap.ophis.fi / ophis.fi, then explorer.ophis.fi).
• Landing landing-deploy.yml: path-filtered build with a Playwright and Lighthouse budget gate, to Cloudflare Pages.
• Docs docs-deploy.yml: the Docusaurus site to its own Cloudflare Pages project.
• MCP server mcp-deploy.yml: to Cloudflare Workers (custom domain mcp.ophis.fi) with a least-privilege Workers token; mcp-registry-release.yml publishes matching versioned metadata to the official MCP Registry from protected mcp-v* tags.
• Trade indexer rebate-indexer-deploy.yml: to self-hosted infrastructure over a private network.
• Operated-chain backends: the Optimism, Unichain, Robinhood Chain, and Arc orderbooks, autopilots, drivers, and solver lanes run on Ophis infrastructure from infra/optimism-mainnet/, infra/unichain-mainnet/, infra/robinhood-mainnet/, and infra/arc-mainnet/. They are not deployed by a GitHub workflow.

Quality gates: ci.yml (lint, typecheck, tests), codeql.yml, security.yml (dependency and supply-chain scans), and echidna.yml (contract fuzzing). sdk-release.yml publishes @ophis/sdk to npm. All package and MCP publishing controls are documented in the release runbook.

Fees, attribution and trade rewards

On every supported chain, Ophis charges a 0.01% (1 bp) base. It also charges a capped share of reference-quote improvement: 80% capped at 99 bps for volatile pairs and 50% capped at 20 bps for stable pairs. The operated-chain backends apply the improvement policy; hosted orders encode it in CIP-75 appData and separately pay CoW Protocol's upstream fees.

• Referral attribution. Create a code in the swap app and share https://swap.ophis.fi/?ref=YOURCODE. Orders carry attribution through appCode and referral metadata; MCP clients pass referrerCode to build_order. Track routed volume in the earnings report at https://rebates.ophis.fi/earnings/<appCode>.
• Trade rewards. The USDG campaign is live at swap.ophis.fi/#/rewards.
• Partner fees. Partners can charge their own fee on CoW-hosted chains. CoW pays it weekly when the weekly amount reaches 0.001 WETH.

Details: fees, referral attribution, and partner integration.

Security

See SECURITY.md for the disclosure policy, canonical contract addresses, the partner-fee recipient and governance model, in-scope components, and audit history.

License

GPL-3.0, inherited from upstream CoW Protocol.