Polymarket AI Prediction Market Agent with MewCP | MewCP

Every other agent in this series eventually asks a human to approve an action that's expensive to get wrong: a production deploy, a customer-facing email, a task assigned to the wrong owner. Polymarket is the one where getting it wrong costs money directly. An order that fills is a real position, denominated in real funds, and there's no "redeploy" button for a bad trade.

That makes it a good case study for a narrower question than the rest of the series has asked: not just "when should a human approve this," but "what's the largest single action this agent should ever be allowed to take without a second thought." This article builds an agent that reads live prediction-market odds, checks a wallet's positions and trade history, and places limit orders on Polymarket, gated behind both explicit human approval and a hard, code-enforced size cap.

We'll connect Polymarket through MewCP, using its Polymarket MCP server, which wraps Polymarket's public market data and its CLOB (central limit order book) trading API behind one set of MCP tools.

What We're Building

User: "What's the market saying about <event>, and buy $20 of YES if it's under 30%"
  ↓
AI Agent
  ↓
MewCP → Polymarket: get_events / get_markets (find the market)
  ↓
MewCP → Polymarket: get_market, get_orderbook, get_midpoint (resolve pricing)
  ↓
Agent evaluates the stated condition against live price

flowchart LR
    User --> Agent[AI Agent]
    Agent -->|search / get_schema / call_tool| Gateway[MewCP Gateway]
    Gateway --> Polymarket[Polymarket MCP server]
    Polymarket -->|read: markets, events, orderbook, positions| Data[Public Market Data]
    Polymarket -->|write: create_order, cancel_order| CLOB[Polymarket CLOB]
    CLOB --> Fill[Order Filled or Open]

You are a prediction-market research and trading agent for Polymarket,
connected through MewCP.
 
Your job, in order:
1. When asked about a market or event, look it up via get_events or
   get_markets, then pull the live orderbook and midpoint before stating
   any price or probability. A market's price is its implied probability,
   0 to 1: report it as a percentage when explaining odds in plain
   language, but never estimate or recall a price from memory.
2. When asked to check positions or trade history, use the wallet address
   the user provides. Do not assume a wallet address.
3. Before calling create_order, state the fully resolved order in plain
   terms: the market question (not just an ID), side (BUY or SELL), price,
   size, and total estimated cost (price x size). Wait for explicit
   approval. Never place an order from a vague instruction like "buy some":
   resolve it to exact numbers first, then confirm those exact numbers.
4. Never propose or place an order above the configured maximum size,
   regardless of what the user asks. If a request exceeds the cap, say so
   and explain the cap rather than scaling the order down silently or
   proceeding anyway.
5. If a market's orderbook is thin or empty, warn about slippage risk
   before proposing an order into it.
6. Treat cancel_order as a write action requiring the same approval step
   as placing an order.
 
Never fabricate a market price, a wallet position, or an order's fill
status. If a tool call fails, say so plainly and stop. If the user asks
"what would happen" or similar, resolve and state the order without
calling create_order at all.

// mewcp-client.ts
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 
const GATEWAY_URL = "https://gateway.mewcp.com/personal/mcp";
 
export async function connectMewCP(mewcpKey: string) {
  const transport = new StreamableHTTPClientTransport(new URL(GATEWAY_URL), {
    requestInit: {
      headers: {
        Authorization: `Bearer ${mewcpKey}`,
        Accept: "application/json, text/event-stream",
      },
    },
  });
 
  const client = new Client({ name: "polymarket-agent", version: "1.0.0" });
  await client.connect(transport);
  return client;
}

// tools.ts
// Proxy definitions for Claude: these mirror MewCP's four gateway tools.
// See https://docs.mewcp.com/mewcp/connect/typescript for the underlying client calls.
 
export const claudeTools = [
  {
    name: "search",
    description: "Find MCP tools by keyword across every connected app.",
    input_schema: {
      type: "object",
      properties: { query: { type: "string" } },
      required: ["query"],
    },
  },
  {
    name: "get_schema",
    description: "Get the parameter schema for specific tools before calling them.",
    input_schema: {
      type: "object",
      properties: {
        tools: {
          type: "array",
          items: {
            type: "object",
            properties: {
              server_maskedId: { type: "string" },
              tool_name: { type: "string" },
            },
            required: ["server_maskedId", "tool_name"],
          },
        },
      },
      required: ["tools"],
    },
  },
  {
    name: "call_tool",
    description: "Execute a tool against a connected app. create_order and cancel_order require operator approval and are checked against a maximum order size.",
    input_schema: {
      type: "object",
      properties: {
        server_maskedId: { type: "string", description: "e.g. 'polymarket'" },
        tool_name: { type: "string" },
        args: { type: "object" },
      },
      required: ["server_maskedId", "tool_name", "args"],
    },
  },
];

// dispatch.ts
import readline from "node:readline/promises";
import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
 
const WRITE_TOOLS = new Set(["polymarket_create_order", "polymarket_cancel_order"]);
 
// Hard ceiling in USDC (roughly: price x size, since price is 0-1 per share).
// This is a floor of caution, not a suggestion: it does not change based on
// what the user asks for in a single message.
const MAX_ORDER_COST_USDC = 50;
 
async function confirmTrade(input: {
  server_maskedId: string;
  tool_name: string;
  args: Record<string, any>;
}): Promise<boolean> {
  console.log("\n--- TRADE APPROVAL REQUIRED ---");
  console.log(`${input.tool_name} on ${input.server_maskedId}`);
  console.log(JSON.stringify(input.args, null, 2));
  if (input.tool_name === "polymarket_create_order") {
    const cost = Number(input.args.price) * Number(input.args.size);
    console.log(`Estimated cost: ~${cost.toFixed(2)} USDC`);
  }
 
  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
  const answer = await rl.question("Approve this trade? (yes/no): ");
  rl.close();
  return answer.trim().toLowerCase() === "yes";
}
 
export async function dispatchTool(
  mewcp: Client,
  name: string,
  input: any
): Promise<unknown> {
  if (name === "call_tool" && WRITE_TOOLS.has(input.tool_name)) {
    if (input.tool_name === "polymarket_create_order") {
      const cost = Number(input.args.price) * Number(input.args.size);
      if (!Number.isFinite(cost) || cost > MAX_ORDER_COST_USDC) {
        return {
          error: "order_exceeds_risk_cap",
          max_allowed_usdc: MAX_ORDER_COST_USDC,
          requested_usdc: cost,
        };
      }
    }
 
    const approved = await confirmTrade(input);
    if (!approved) {
      return { error: "rejected_by_operator", tool_name: input.tool_name };
    }
  }
 
  return mewcp.callTool({ name, arguments: input });
}

// agent.ts
import Anthropic from "@anthropic-ai/sdk";
import { connectMewCP } from "./mewcp-client";
import { claudeTools } from "./tools";
import { dispatchTool } from "./dispatch";
import { SYSTEM_PROMPT } from "./system-prompt";
 
const anthropic = new Anthropic();
 
export async function runPolymarketAgent(userMessage: string) {
  const mewcp = await connectMewCP(process.env.MEWCP_KEY!);
 
  const messages: Anthropic.MessageParam[] = [
    { role: "user", content: userMessage },
  ];
 
  while (true) {
    const response = await anthropic.messages.create({
      model: "claude-sonnet-5",
      max_tokens: 2048,
      system: SYSTEM_PROMPT,
      tools: claudeTools,
      messages,
    });
 
    messages.push({ role: "assistant", content: response.content });
 
    if (response.stop_reason !== "tool_use") {
      return response.content
        .filter((block): block is Anthropic.TextBlock => block.type === "text")
        .map((block) => block.text)
        .join("\n");
    }
 
    const toolResults: Anthropic.ToolResultBlockParam[] = [];
    for (const block of response.content) {
      if (block.type !== "tool_use") continue;
      let output: unknown;
      try {
        output = await dispatchTool(mewcp, block.name, block.input);
      } catch (err) {
        output = { error: err instanceof Error ? err.message : String(err) };
      }
      toolResults.push({
        type: "tool_result",
        tool_use_id: block.id,
        content: JSON.stringify(output),
      });
    }
    messages.push({ role: "user", content: toolResults });
  }
}

Agent receives: "what are the odds on <event>?"
        ↓
search({ query: "polymarket events" })
        ↓
finds: server_maskedId="polymarket", tool_name="get_events"
        ↓
get_schema({ tools: [{ server_maskedId: "polymarket", tool_name: "get_events" }] })
        ↓
call_tool(...) → matches the event, extracts the relevant market
        ↓
repeats for get_market, get_orderbook, get_midpoint to resolve live pricing
        ↓
if a trade is requested: repeats once more for create_order, gated by risk cap + approval

Failure	Where it surfaces	Agent behavior
No Polymarket trading key connected	`call_tool` on `create_order` returns a connect link	Surface the link, don't attempt to place the order
Market/event not found	`get_events` / `get_markets` return nothing matching	Say so, ask for clarification instead of guessing the closest match
Thin or empty orderbook	`get_orderbook` returns few or no levels	Warn about slippage before proposing a price, don't propose one blind
Order exceeds the risk cap	Dispatcher rejects before showing the approval prompt	Explain the cap and the requested amount, don't silently scale down
Invalid price (outside 0-1) or malformed size	API returns a validation error	Report the exact error, don't retry with a guessed correction
Insufficient balance/allowance	`create_order` fails	Surface the failure plainly, don't retry
Rate limiting under repeated polling	`call_tool` returns a 429-shaped error	Back off once, retry once, then report
Operator rejects the trade	`confirmTrade` returns false	Acknowledge and stop, don't retry the same call

Polymarket AI Prediction Market Agent with MewCP

Polymarket AI Prediction Market Agent with MewCP

What We're Building

Architecture

Prerequisites

Connecting the MCP Server

Agent Design

Agent Instructions

Implementation

Tool Discovery and Execution

Error Handling

Security

Testing the Agent

Production Considerations

What This Demonstrates

What We're Building

Architecture

Prerequisites

Connecting the MCP Server

Agent Design

Agent Instructions

Implementation

Tool Discovery and Execution

Error Handling

Security

Testing the Agent

Production Considerations

What This Demonstrates

Related MewCP Guides