Otto Intel MCP

Market intelligence and trade construction for AI agents, over MCP: SEC filings and insider flow for US stocks, tokenized equities on Robinhood Chain, Base and Polymarket market context, plus four constructors that build a ready-to-sign swap, bridge, Polymarket order or Hyperliquid perp order for an address you supply. Pay per call in USDC on Base; on the hosted server the first call from your network address is free.

• Hosted: https://mcp.ottoai.services — 22 tools.
• Local: npx otto-intel-mcp — the 10 intelligence tools, paid from a wallet you configure.
• Docs: https://docs.useotto.xyz/acp-swarm/otto-intel-mcp

Quick start (hosted, under a minute)

Claude Code

claude mcp add otto-intel --transport http https://mcp.ottoai.services

Cursor, Claude Desktop, Codex CLI, any MCP client — add a remote server with this URL (Cursor: ~/.cursor/mcp.json; Claude Desktop: Connectors → add custom connector; Codex: codex mcp add otto-intel --url https://mcp.ottoai.services):

{
  "mcpServers": {
    "otto-intel": { "url": "https://mcp.ottoai.services" }
  }
}

First call — ask your agent, or call the tool directly:

Use otto_pm_crypto and summarize the top three markets.

{ "method": "tools/call", "params": { "name": "otto_pm_crypto", "arguments": {} } }

(a standard MCP tools/call request — your MCP client wraps it in JSON-RPC and handles initialize and the Streamable HTTP session)

That call is free (one per network address). The next one returns a payment request; your agent signs it with an x402 wallet and retries with the signed payload in x_payment — see How paying works.

Quick start (local)

Runs the 10 intelligence tools on your machine and pays each call from a wallet you provide. It needs one variable, X402_PRIVATE_KEY — the key of a wallet holding some USDC on Base.

Claude Code

claude mcp add otto-intel -e X402_PRIVATE_KEY=0x… -- npx -y otto-intel-mcp

Any MCP client (stdio) — Cursor: ~/.cursor/mcp.json; Claude Desktop: claude_desktop_config.json:

{
  "mcpServers": {
    "otto-intel": {
      "command": "npx",
      "args": ["-y", "otto-intel-mcp"],
      "env": { "X402_PRIVATE_KEY": "0x…" }
    }
  }
}

Requires Node 22 or newer. Optional: X402_RPC_URL (your own Base RPC), X402_TIMEOUT_MS (default 30000). The local server serves the 10 intelligence tools only — the four constructors are hosted-only: to get an envelope, call otto_prepare_swap on https://mcp.ottoai.services (free). A paid local call carries the rail's settlement receipt in the result metadata under com.ottoai/payment-response, exactly like the hosted server.

npm audit on a fresh install reports findings that all sit in the local server's third-party venue clients (@polymarket/clob-client-v2 → ethers v5 → ws, @nktkas/hyperliquid → valibot, the optional @coinbase/cdp-sdk → an older axios), none of which the library entries (otto-intel-mcp/execution, /adapter, /adapter-cdp) or otto-execute load — otto-execute on its own installs 19 packages with 0 findings. npm install otto-intel-mcp --omit=optional drops the Coinbase subtree if you do not delegate.

What you get

Intelligence tools — hosted and local

| Tool | Argument | Returns | Price | | --- | --- | --- | ---: | | otto_tokenized_equities | optional thesis | The live registry of US stocks and ETFs tokenized on Robinhood Chain — symbol, token address, reference price, tradability; with a thesis, a ranked shortlist with a match reason per row | $0.001 | | otto_rh_season | — | Robinhood Chain movers, rug-screened, with per-token risk flags | $0.001 | | otto_equity_intel | ticker | SEC fundamentals for a US ticker: revenue and net-income trend, margins, EPS, leverage, recent 10-K / 10-Q / 8-K filings, and a short summary | $0.003 | | otto_insider_trades | ticker | Parsed SEC Form 4 insider transactions: purchases vs sales, dollar values, roles, net balance | $0.003 | | otto_institutional_holdings | manager (CIK or ticker, e.g. 1067983 or BLK) | The latest 13F-HR top positions for an institutional manager, amendments applied | $0.003 | | otto_equity_smart_money | ticker | Form 4 insider activity plus trailing-twelve-month XBRL fundamentals in one bundle | $0.006 | | otto_equity_smart_money_brief | ticker | One AI-written brief over Form 4 flow, 13D/13G ownership events and fundamentals | $0.10 | | otto_base_season | — | Quality-screened Base tokens with current social and trusted-KOL context | $0.002 | | otto_pm_markets | — | The highest-volume open Polymarket markets: outcome probabilities, bid/ask, liquidity, volume, end dates | $0.001 | | otto_pm_crypto | — | The same for BTC, ETH and crypto Polymarket markets | $0.001 |

All of these return data and context, not recommendations.

Execution constructors — hosted, free

A constructor builds the transaction; your wallet signs and sends it. Give it the address that will sign, and it returns an envelope: the ordered steps (for example allowance reset → approval → swap), every check it ran on its own output, a valid_until, and a digest so a stale or altered plan is detectable. Otto Intel MCP itself never signs or submits.

| Tool | Builds | For | | --- | --- | --- | | otto_prepare_swap | A same-chain ERC-20 swap via LI.FI, as ready-to-sign steps | Your EOA or Safe on any supported EVM chain | | otto_prepare_bridge | A cross-chain native-USDC bridge over Circle CCTP (Ethereum, Polygon, Base, Arbitrum, Avalanche) | Your EOA or Safe | | otto_prepare_polymarket_order | A Polymarket CTF Exchange V2 limit order as typed data, tick and size validated against the live market | Your Polygon EOA | | otto_prepare_perp_order | A Hyperliquid perp limit order (optional take-profit / stop-loss), as the L1 action plus the exact EIP-712 recipe to sign | Your Hyperliquid account |

On a server with a chain view (the hosted rail), a quoted swap route is also simulated from the address that will sign it before it is prepared: the quote's shape is asserted first, then the asserted call is run against the node with the plan's own balance and allowance overridden. A route that reverts is re-quoted with that exchange denied; a route that cannot be simulated — a token whose storage layout has not been proven on-chain, a node that ignores overrides — is refused by name rather than prepared unproven. Today the proven tokens are USDC on Base and the two Yield Copilot vault shares (gtUSDCp, steakUSDC).

To verify, sign and submit an envelope from the command line or from code, use the companion otto-execute (CLI + library, npm install otto-execute) — see the execution seam docs.

Always free

• otto_catalog — the complete live Otto x402 menu (paths, descriptions, prices, payment details).
• otto_x_recipes — Otto X's X Layer recipe menu with each recipe's payment requirement.
• otto_delegation_fence_status — whether the delegated-send fence is installed on this server (read-only).

The other four otto_delegation_* / otto_submit_under_delegation tools are server-to-server (they need Otto's delegation header); an agent reaches that path through otto-execute delegate, documented on the execution-seam page.

How paying works

Calls are priced per tool ($0.001–$0.10) and paid in USDC on Base through x402. On the hosted server the first successful intelligence call from your network address (IP) is free; every call after that needs a payment:

1. Call the tool without x_payment → it returns payment_required (below) with the price and the exact requirement.
2. Sign it with an x402 client from a wallet holding USDC on Base. With @x402/core + @x402/evm + viem:

import { x402Client } from '@x402/core/client';
import { encodePaymentSignatureHeader } from '@x402/core/http';
import { ExactEvmScheme } from '@x402/evm/exact/client';
import { toClientEvmSigner } from '@x402/evm';
import { createPublicClient, http } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { base } from 'viem/chains';

const account = privateKeyToAccount(process.env.X402_PRIVATE_KEY as `0x${string}`);
const signer = toClientEvmSigner(account, createPublicClient({ chain: base, transport: http() }));
const client = new x402Client((_version, requirements) => requirements[0]); // pick accepts[0]
client.register('eip155:*', new ExactEvmScheme(signer));

const payload = await client.createPaymentPayload(result.payment_required); // the 402 body
const x_payment = encodePaymentSignatureHeader(payload); // base64 — the PAYMENT-SIGNATURE header value

3. Retry the same tool with that string in x_payment. The paid result carries the settlement receipt in its metadata under com.ottoai/payment-response — keep it; it is the proof a later rating or refund claim is made against.

If a route has no result for your input, it answers promptly and the free call is not consumed. If a paid delivery is interrupted, retry the same input with the same x_payment: the settled response is replayed without a second charge, or the attempt completes if it was never charged.

payment_required is the standard x402 v2 body (accepts[0] is the requirement to sign; payment.requirement is the same one, flattened for reading; payment_required_header is it base64-encoded for clients that consume the header form). Each requirement is valid for 300 seconds. If your MCP client has no x402 wallet of its own, the local server is the simplest route: it signs every payment from X402_PRIVATE_KEY automatically, with no free call.

For agents: exact shapes

Intelligence tools take their one argument plus an optional x_payment string. Example, first call:

{ "name": "otto_equity_intel", "arguments": { "ticker": "NVDA" } }

A successful result is one text part containing JSON — otto_pm_crypto returns, abbreviated:

{
  "status": "success",
  "data": {
    "venue": "polymarket",
    "markets": [
      {
        "question": "Will the price of Bitcoin be above $70,000 on September 2?",
        "outcomes": [{ "outcome": "Yes", "probability": 0.999 }, { "outcome": "No", "probability": 0.001 }],
        "bestBid": 0.998, "bestAsk": 1, "liquidityUsd": 14749.24, "volume24hUsd": 103765.46,
        "endDate": "2026-09-02T16:00:00Z", "url": "https://polymarket.com/event/bitcoin-above-on-september-2-2026"
      }
    ]
  }
}

An unpaid call after the free one returns isError: true with this payload (abbreviated) — sign it with an x402 client and retry with the encoded payload in x_payment:

{
  "error": "payment_required",
  "status": 402,
  "protocol": "x402",
  "tool": "otto_pm_crypto",
  "price_usdc": "0.001",
  "payment": {
    "network": "eip155:8453",
    "asset": "USDC",
    "amount_atomic": "1000",
    "requirement": {
      "scheme": "exact",
      "network": "eip155:8453",
      "amount": "1000",
      "asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
      "payTo": "0x0E84dDEdAaE6A779c462C22a59F301EC31B6b808",
      "maxTimeoutSeconds": 300,
      "extra": { "name": "USD Coin", "version": "2" }
    }
  },
  "payment_required": { "x402Version": 2, "accepts": ["…the same requirement, x402 v2 shape…"] },
  "payment_required_header": "<base64 of payment_required>",
  "retry": { "tool": "otto_pm_crypto", "argument": "x_payment", "forwarding_header": "PAYMENT-SIGNATURE" }
}

Constructor arguments (addresses are 0x + 40 hex; swap and bridge amounts are strings in atomic token units; Polymarket price/size and Hyperliquid size/price are plain decimal strings):

{
  "name": "otto_prepare_swap",
  "arguments": {
    "accountProfile": { "kind": "eoa", "address": "0xYourAddress", "chainId": 8453 },
    "chainId": 8453,
    "fromToken": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
    "toToken": "0x4200000000000000000000000000000000000006",
    "fromAmount": "1000000",
    "slippage": { "maxBps": 50, "minAmountOut": "400000000000000" },
    "client_ref": "my-trade-1"
  }
}

• otto_prepare_bridge: accountProfile, fromChainId, toChainId, fromToken, toToken (native USDC on each side), fromAmount, slippage, optional destinationRecipient (required for a Safe).
• otto_prepare_polymarket_order: accountProfile (chainId 137), tokenId (the outcome token, not the condition id), side BUY|SELL, price (e.g. "0.045", on the market's tick), size (shares).
• otto_prepare_perp_order: accountProfile (chainId 1337), asset (e.g. "BTC"), side, size, limitPrice, optional timeInForce Gtc|Ioc|Alo, reduceOnly, takeProfitPrice, stopLossPrice, tradingSigner, vaultAddress.

Every tool's full description and JSON schema comes back from tools/list.

Using this package as a library

Three import paths, for code that consumes what the constructors produce (there is no root import — use the subpaths):

• otto-intel-mcp/execution — the envelope schema and types, the digest and freshness assertions, the fee and delegation constants.
• otto-intel-mcp/adapter — verify an envelope against your own intent and sign or submit it with an EOA.
• otto-intel-mcp/adapter-cdp — the same over a Coinbase CDP delegation (@coinbase/cdp-sdk is an optional dependency, loaded only here).

Field-by-field documentation: https://docs.useotto.xyz/acp-swarm/execution-seam.

Links

• Docs: https://docs.useotto.xyz/acp-swarm/otto-intel-mcp · execution seam: https://docs.useotto.xyz/acp-swarm/execution-seam
• The full Otto x402 catalog: https://x402.ottoai.services
• Otto AI: https://useotto.xyz · X: @useOttoAI
• Changelog: 0.1.3 — swap-shaped constructors on a server with a chain view now SIMULATE the quoted route from the signing account before preparing it (a reverting exchange tool is re-quoted and denied; an unprovable route is refused by name — see the execution constructors section), and the library entries ship the fence-v2 policy lineage (MODEL_B_POLICY_*_V2, MODEL_B_POLICY_DIGEST_BY_NAME) that the otto-execute CLI needs to recognise the current fence; 0.1.2 — the hosted front door (GET /, /health) reports the live tool registry (21 tools, never a literal), the local server carries the settlement receipt like the hosted one, constructor descriptions state the freshness window, serverInfo.version = the package version; 0.1.1 — README rewritten for first-time users and agents, source maps removed from the package, publish gated by a privacy audit; 0.1.0 — first release (hosted + local server, execution constructors, library entries).

Running the hosted server yourself, or building from the monorepo: see SETUP.md in the repository.