Composable agent tools — OpenClaw skills, MCP servers, and modular frameworks — let you build prediction market trading agents from interchangeable parts instead of monolithic code. This guide covers both paradigms, the prediction market APIs they connect to, and the architecture patterns that work in production.
The composability thesis
Monolithic trading bots break when markets change. You wrote a Polymarket bot, now you want to add Kalshi — that’s a rewrite. Your analysis model improves from GPT-4 to Claude — another rewrite. Your wallet moves from a hot wallet to a Coinbase Agentic Wallet — yet another rewrite.
Composable agent tools solve this. Each capability is an independent module. Swap the market connector without touching the analysis logic. Upgrade the LLM without rebuilding the execution layer. Add a new market by installing a single skill or connecting a new MCP server.
Two paradigms dominate composable agent tooling for prediction markets:
- OpenClaw skills — Drop-in modules on the ClawHub registry, installed via CLI, running within OpenClaw’s agent runtime
- MCP servers — Protocol-level standard for agent-to-platform connections, framework-agnostic
Both map onto the Agent Betting Stack. Both are production-viable today. They solve the same problem differently.
OpenClaw skills: the marketplace model
OpenClaw skills are composable modules defined in Markdown files (SKILL.md) with YAML frontmatter, plus optional reference docs and executable scripts. A complete skill can be implemented in roughly 20 lines of code. The ClawHub registry hosts 13,729+ community-built skills, with a curated third-party list tracking 5,400+ more.
How skills work
SKILL.md (Markdown + YAML frontmatter)
├── Metadata: name, version, description, author
├── Instructions: what the skill does, when to invoke it
├── Tool definitions: shell commands, API calls, browser actions
└── Optional: reference docs, Python/JS scripts
Skills are discovered by the agent runtime at startup but selectively injected per-turn — the full 13,729+ skills are not loaded into every prompt. The runtime matches the user’s intent to relevant skills and injects only those into the LLM context.
Installation is trivial:
# From ClawHub registry
openclaw skill install polyclaw
# From any GitHub repo
# Paste the URL directly into an OpenClaw chat
Prediction market skills
| Skill | Market | Execution Model | Standout Feature |
|---|---|---|---|
| PolyClaw | Polymarket | Split + CLOB orders | LLM hedge discovery via contrapositive logic |
| BankrBot | Polymarket + DeFi | Multi-strategy (spot, leveraged, PM) | Covers 50x leverage + NFTs alongside PM |
| Solana CLI PM | Polymarket, Kalshi | Jupiter/Solana routing | Cross-platform via single Solana interface |
| ClawArena | Custom markets | Agent-created markets | Agents create, bet, and settle their own markets |
| Argus Edge | Multi-platform | Edge detection | Probability deviation analysis across markets |
Skills security model
The openness that makes ClawHub powerful also makes it dangerous. Cisco’s audit of 31,000 skills found 26% contained at least one vulnerability. The “ClawHavoc” attack uploaded 341 malicious skills that installed macOS malware. For trading agents holding wallet credentials, an unaudited skill is a direct path to drained funds.
The mitigation: read every SKILL.md before installing. Skills are small and human-readable by design. A five-minute review catches most issues.
MCP servers: the protocol model
The Model Context Protocol (MCP) takes a different approach. Instead of marketplace modules tied to a specific framework, MCP defines a universal protocol for agent-to-platform connections. Any MCP-compatible agent can discover and invoke tools exposed by any MCP server.
Think of it as USB-C for AI agents. The agent doesn’t need to know the internal implementation of the Polymarket API — it just connects to a Polymarket MCP server that exposes structured tool definitions.
How MCP works for prediction markets
┌──────────────────┐ MCP Protocol ┌──────────────────┐
│ AI Agent │◄────────────────────►│ Polymarket MCP │
│ (any framework)│ discover tools │ Server │
│ │ invoke tools │ │
│ │ receive results │ - get_markets() │
│ │ │ - place_order() │
│ │ │ - get_positions()│
└──────────────────┘ └──────────────────┘
│
│ MCP Protocol
│◄────────────────────►┌──────────────────┐
│ │ Kalshi MCP │
│ │ Server │
│ │ │
│ │ - list_events() │
│ │ - create_order() │
│ │ - get_portfolio()│
└──────────────────────└──────────────────┘
MCP servers exist for Polymarket, Kalshi, Manifold, and PredictIt. A single agent can trade across all four using the same protocol. Add a new market by connecting a new server — zero code changes in your agent.
MCP vs. OpenClaw skills
| Dimension | OpenClaw Skills | MCP Servers |
|---|---|---|
| Portability | OpenClaw only | Any MCP-compatible agent |
| Ecosystem size | 13,729+ on ClawHub | Growing, fewer PM-specific servers |
| Complexity to build | ~20 lines of Markdown + code | Full server implementation |
| Installation | openclaw skill install <name> | Connect server URL to agent config |
| Security model | Community-reviewed, auditable | Server operator controls trust |
| Best for | OpenClaw users who want plug-and-play | Multi-framework teams, enterprise |
They’re not mutually exclusive. OpenClaw itself can consume MCP servers as tool sources, giving you both the skills ecosystem and protocol-level interoperability.
The four-layer integration architecture
Regardless of which composability paradigm you use, prediction market agent platforms follow the same integration pattern:
┌─────────────────────────────────────────┐
│ Layer 4: RISK MANAGEMENT │
│ Position limits, stop-losses, │
│ exposure caps, drawdown rules │
├─────────────────────────────────────────┤
│ Layer 3: EXECUTION │
│ Order routing, split orders, │
│ CLOB interaction, fill confirmation │
├─────────────────────────────────────────┤
│ Layer 2: STRATEGY │
│ LLM analysis, signal generation, │
│ multi-agent ensemble, edge detection │
├─────────────────────────────────────────┤
│ Layer 1: DATA │
│ Market feeds, news ingestion, │
│ WebSocket streams, social signals │
└─────────────────────────────────────────┘
The most successful autonomous trading agents use hard-coded rules at Layers 3 and 4 (execution and risk management) with AI decision-making at Layers 1 and 2 (data analysis and strategy). This hybrid architecture is more reliable than pure AI control because execution discipline and risk limits should never be subject to LLM hallucination.
Prediction market APIs: what’s composable
The composability of your agent depends on what the underlying platforms expose. Here’s the current state:
Polymarket
The most comprehensive and bot-friendly API in the prediction market space:
- CLOB API: REST + WebSocket for order management
- Gamma API: Market metadata, resolution criteria, historical data
- WebSocket channels: price, book, trade, user (real-time streaming)
- Auth: Ed25519 key signing
- Settlement: USDC on Polygon
- Rate limits: 60 REST requests/min, generous WebSocket limits
- SDKs: Official Python and TypeScript
Full details in the Prediction Market API Reference.
Kalshi
CFTC-regulated designated contract market with solid API support:
- REST + WebSocket APIs with API key authentication and request signing
- Token expiry: 30 minutes (auto-refresh required)
- Latency: 50-200ms typical (medium-frequency strategies only)
- Fees: 0% trading fees (currently)
- Best for: Event-driven strategies, not high-frequency
Manifold Markets
Play-money platform that explicitly encourages bot development:
- Comprehensive public API with generous rate limits
- Bot competitions with real cash prizes
- Ideal for prototyping and backtesting before deploying to Polymarket/Kalshi
Metaculus
Forecasting-focused with a framework called forecasting-tools:
- Template bots rank in the top 10 using basic GPT-4 implementations
- Tournament prize pools where winning bots have earned $9,500 ($240/hour equivalent)
- Good training ground for calibration-focused agents
Traditional sportsbooks
Effectively closed to agents. DraftKings and similar platforms explicitly prohibit automated betting in their Terms of Service and expose no public trading API. The practical path for sports betting agents runs through odds aggregator APIs — see the tools directory for options.
Multi-agent ensembles: the production pattern
Single-model agents underperform in prediction markets. The production pattern that works: multi-agent ensembles where different agents use different reasoning approaches, and their outputs are aggregated via weighted methods.
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ Agent 1 │ │ Agent 2 │ │ Agent 3 │
│ Chain of │ │ Tree of │ │ ReAct │
│ Thought │ │ Thought │ │ Pattern │
│ (Claude) │ │ (GPT) │ │ (Gemini) │
└──────┬──────┘ └──────┬──────┘ └──────┬──────┘
│ │ │
└────────────────┼────────────────┘
│
┌────────▼────────┐
│ Bayesian │
│ Aggregation │
│ (weighted by │
│ historical │
│ calibration) │
└────────┬────────┘
│
┌────────▼────────┐
│ Execution │
│ (hard-coded │
│ risk rules) │
└─────────────────┘
Polyseer implements this pattern directly — multi-agent Bayesian analysis for Polymarket and Kalshi. CrewAI provides the orchestration layer for role-based multi-agent systems where you can assign different agents to research, analysis, and execution roles.
The key insight from production systems: model accuracy matters less than execution discipline. A mediocre signal with proper risk management outperforms a brilliant signal with sloppy execution. Hard-code your position limits, stop-losses, and maximum exposure. Let the AI handle market selection and timing.
What’s next
- OpenClaw Prediction Market Guide — Full setup and configuration for OpenClaw trading agents
- Prediction Market API Reference — Detailed API docs for Polymarket, Kalshi, and more
- Agent Betting Stack Overview — The four-layer model for autonomous betting agents
- Agent Wallet Comparison — Choosing the right wallet for your agent
- Tool Marketplace — Browse all agent tools and platforms