Architecture Deep Dive

Integration Platform for OpenClaw AI Agents to Execute Prediction Market Trades

---

Executive Summary

MoltMarket is an OpenClaw skill and plugin ecosystem that enables autonomous AI agents to securely execute trades on prediction markets including Polymarket and Kalshi. By abstracting API complexity, wallet management, and exchange-specific protocols into natural language-driven tools, MoltMarket allows OpenClaw agents to analyze probabilities, detect arbitrage, execute trades, and manage positions without understanding low-level market mechanics.

Key Value Proposition: Transform prediction market trading from developer-only API integrations into natural language agent operations with enterprise-grade security and cross-platform compatibility.

---

1. Market Context & Opportunity

1.1 The Prediction Market Landscape (2026)

Prediction markets have experienced explosive growth, with total notional trading volume reaching $50.25 billion in 2025, up from $9 billion in 2024. Two platforms dominate the ecosystem:

Polymarket (Polygon-based, decentralized)

• Largest prediction market platform globally

• $18+ billion in trading volume (2024-2025)

• USDC-denominated markets on Polygon blockchain

• Decentralized architecture with smart contract settlement

• Open API with public data access (Gamma API, Data API, CLOB API)

• Geographic restrictions in certain jurisdictions

Kalshi (CFTC-regulated, US-based)

• CFTC-regulated Designated Contract Market (DCM)

• USD-settled prediction markets

• ~1,600 event contracts listed in 2025

• REST API, WebSocket, and FIX protocol support

• Institutional-grade compliance and regulatory oversight

• Restricted to US users and compliant jurisdictions

1.2 The Rise of OpenClaw AI Agents

OpenClaw (formerly Clawdbot, Moltbot, Molty) is an open-source autonomous AI agent framework that achieved viral adoption in early 2026:

• 247,000 GitHub stars and 47,700 forks as of March 2026

• Developed by Peter Steinberger, later acquired by OpenAI

• 100+ built-in skills connecting AI models to apps, browsers, and system tools

• Integration with Claude, GPT-4, DeepSeek, and other LLMs

• 5,400+ community skills in the ClawHub registry

• Messaging-first interface (Signal, Telegram, Discord, WhatsApp)

OpenClaw Architecture: Exposes three extension types:

1. Skills - Natural language API integrations defined in SKILL.md files

2. Plugins - Deep runtime extensions written in TypeScript/JavaScript

3. Webhooks - HTTP endpoints for external system notifications

1.3 AI Agents in Prediction Markets

AI agents are rapidly becoming dominant traders in prediction markets:

Polystrat Case Study (February 2026):

• Autonomous AI agent trading on Polymarket

• 4,200+ trades executed in first month

• 376% returns on individual trades

• 24/7 autonomous operation with natural language strategy definition

• Built on Valory AG's Olas protocol for blockchain interaction

Market Dynamics:

• AI agents can identify probability discrepancies faster than humans

• 24/7 operation enables continuous arbitrage detection

• Natural language strategy definition lowers barrier to entry

• Agents outperform human traders in certain market conditions

1.4 The Integration Gap

Despite this convergence, a critical gap exists:

Current State: Prediction market APIs are designed for traditional web applications, requiring developers to:

• Understand REST API endpoints, authentication schemes, and rate limits

• Manage wallet private keys and sign blockchain transactions

• Handle platform-specific order types, collateral models, and settlement flows

• Build custom WebSocket clients for real-time data

• Implement error handling, retry logic, and connection management

Opportunity: Build OpenClaw-native skills and plugins that abstract this complexity, enabling agents to trade prediction markets using natural language commands while maintaining security and compliance.

---

2. Product Definition

2.1 What is MoltMarket?

MoltMarket is a comprehensive integration layer between OpenClaw AI agents and prediction market platforms, delivered as:

1. OpenClaw Skills - Natural language tools for market operations

2. OpenClaw Plugins - Runtime extensions for wallet management and WebSocket streaming

3. MCP Server - Model Context Protocol server for cross-framework compatibility

4. Security Infrastructure - Non-custodial wallet management with programmable guardrails

5. Web Dashboard - Real-time monitoring, analytics, and position management UI

2.2 Core Capabilities

Market Discovery & Analysis

skill: market.search
Purpose: Discover prediction markets matching natural language criteria
Input: "Find presidential election markets with >$1M liquidity"
Output: Ranked list of markets with metadata, liquidity, close dates

Position Management

skill: position.open
Purpose: Open positions with declarative parameters
Input: "Buy $500 YES on Trump winning if probability <45%"
Output: Order confirmation, fill price, position details

Portfolio Monitoring

skill: portfolio.get_positions
Purpose: Track holdings and P&L across platforms
Input: "Show all open positions and unrealized gains"
Output: Position list with entry price, current value, P&L

Probability Analysis

skill: market.get_probabilities
Purpose: Extract market-implied probability distributions
Input: "What's the implied probability for Fed rate cut in June?"
Output: Probability calculations, orderbook depth, spread analysis

Risk Management

skill: position.set_risk_limits
Purpose: Configure stop-loss, position limits, daily loss caps
Input: "Set stop-loss at 35%, max position $1000"
Output: Risk parameters applied to all future trades

2.3 Technical Architecture

┌─────────────────────────────────────────────────────────────┐
│                    OpenClaw Agent Layer                     │
│  ┌───────────────────────────────────────────────────────┐  │
│  │  Natural Language Commands                            │  │
│  │  "Find election markets, buy if probability <45%"     │  │
│  └─────────────────────┬─────────────────────────────────┘  │
└────────────────────────┼────────────────────────────────────┘
                         │
                         │ OpenClaw Skill API
                         │ (SKILL.md + TypeScript/Python handlers)
                         │
                         ▼
┌─────────────────────────────────────────────────────────────┐
│                  MoltMarket Integration Layer                │
│  ┌──────────────────┐  ┌──────────────────┐  ┌───────────┐ │
│  │  Market Skills   │  │ Position Skills  │  │ Portfolio │ │
│  │  - Search        │  │ - Open/Close     │  │ - Monitor │ │
│  │  - Probabilities │  │ - Modify         │  │ - P&L     │ │
│  │  - Orderbook     │  │ - Risk Limits    │  │ - Alerts  │ │
│  └──────────────────┘  └──────────────────┘  └───────────┘ │
│  ┌───────────────────────────────────────────────────────┐  │
│  │  Security Plugin                                      │  │
│  │  - Wallet Management (non-custodial)                  │  │
│  │  - Transaction Signing (Ledger/software)              │  │
│  │  - Approval Workflows (small/large trades)            │  │
│  │  - Rate Limiting & Audit Logging                      │  │
│  └───────────────────────────────────────────────────────┘  │
│  ┌───────────────────────────────────────────────────────┐  │
│  │  Platform Adapters                                    │  │
│  │  - API Authentication (JWT, RSA signatures)           │  │
│  │  - Protocol Translation (REST, WebSocket, FIX)        │  │
│  │  - Response Normalization (unified schemas)           │  │
│  └───────────────────────────────────────────────────────┘  │
└────────────────────────┬────────────────────────────────────┘
                         │
                         │ Platform APIs
                         │ REST + WebSocket + Blockchain RPC
                         │
                         ▼
┌─────────────────────────────────────────────────────────────┐
│              Prediction Market Platforms                     │
│  ┌──────────────────────┐      ┌─────────────────────────┐  │
│  │   Polymarket         │      │        Kalshi           │  │
│  │   - Polygon L2       │      │   - CFTC Regulated      │  │
│  │   - USDC Collateral  │      │   - USD Settlement      │  │
│  │   - Smart Contracts  │      │   - REST/WebSocket/FIX  │  │
│  │   - CLOB API         │      │   - Demo Environment    │  │
│  └──────────────────────┘      └─────────────────────────┘  │
└─────────────────────────────────────────────────────────────┘

---

3. Technical Implementation

3.1 Platform Integration Architecture

Polymarket Integration

Authentication Flow:

// API Key Derivation
POST https://clob.polymarket.com/auth/derive-api-key
Body: {
  address: "0x...",  // Polygon wallet address
  nonce: 1           // Incrementing nonce
}
Response: {
  apiKey: "...",
  secret: "...",
  passphrase: "..."
}

// Trading Authentication
Headers: {
  "POLY-ADDRESS": "0x...",
  "POLY-SIGNATURE": "<signed message>",
  "POLY-TIMESTAMP": "<unix timestamp>",
  "POLY-NONCE": "1",
  "POLY-API-KEY": "...",
  "POLY-PASSPHRASE": "..."
}

API Endpoints:

• Gamma API (https://gamma-api.polymarket.com) - Markets, events, search

• Data API (https://data-api.polymarket.com) - Positions, trades, analytics

• CLOB API (https://clob.polymarket.com) - Orderbook, trading

Key Features:

• Public data access (no auth for market data)

• WebSocket feeds for real-time orderbook updates

• USDC collateral on Polygon blockchain

• No geographic restrictions in API (frontend geo-blocks only)

Kalshi Integration

Authentication Flow:

// Token Authentication
POST https://trading-api.kalshi.com/trade-api/v2/login
Body: {
  email: "[email protected]",
  password: "..."
}
Response: {
  token: "eyJhbGc...",
  expires_at: "2026-03-20T00:00:00Z"
}

// Token expires every 30 minutes - auto-refresh required

API Endpoints:

• REST API - /markets, /events, /orders, /portfolio

• WebSocket API - Real-time market updates, order book changes

• FIX Protocol - Institutional/HFT integration (optional)

Key Features:

• CFTC-regulated exchange (DCM status)

• Demo environment at demo.kalshi.com/trade-api/v2

• RSA-signed requests for sensitive operations

• USD settlement (no crypto required)

3.2 Wallet Security Architecture

Critical Security Requirement: AI agents require transaction signing capabilities while maintaining user custody and preventing unauthorized trades.

Non-Custodial Design

MoltMarket implements a three-tier security model:

Tier 1: Cold Storage (User Controlled)

• Master private key never touches MoltMarket infrastructure

• Stored in hardware wallet (Ledger) or encrypted local keystore

• Used only for high-value transactions or policy changes

• Agent cannot access cold storage directly

Tier 2: Session Keys (Time-Limited)

• Temporary signing keys with programmable limits

• Scoped to specific operations (trading only, no withdrawals)

• Auto-expire after configurable duration (1 hour - 24 hours)

• Implemented using EIP-7702 session permissions (Ethereum/Polygon)

Tier 3: Smart Contract Guardrails

• On-chain spending limits enforced by smart contract

• Maximum per-transaction limit (e.g., $1,000)

• Daily loss limit (e.g., $5,000)

• Whitelisted contract addresses only (Polymarket CTF contracts)

Transaction Approval Workflow

// Small trades (< $100): Auto-approve
if (tradeAmount < AUTO_APPROVE_THRESHOLD) {
  signWithSessionKey(transaction)
  broadcastTransaction()
}

// Medium trades ($100 - $1000): Notification + auto-execute
if (tradeAmount < SESSION_KEY_LIMIT) {
  notifyUser({ trade, reason: "Agent executing medium trade" })
  signWithSessionKey(transaction)
  broadcastTransaction()
}

// Large trades (> $1000): Require hardware wallet confirmation
if (tradeAmount >= SESSION_KEY_LIMIT) {
  requestLedgerApproval({
    to: polymarketContract,
    value: tradeAmount,
    data: encodedTradeData
  })
  // User physically approves on Ledger device
  signWithLedger(transaction)
  broadcastTransaction()
}

Ledger Integration

Following MoonPay Agents' approach (announced March 2026), MoltMarket integrates Ledger hardware signers:

• Transaction Verification: User sees trade details on Ledger screen

• Physical Approval: User presses button to approve

• Private Key Security: Keys never leave secure element

• Phishing Protection: Prevents prompt injection attacks

Implementation:

import { Transport } from '@ledgerhq/hw-transport-node-hid'
import Eth from '@ledgerhq/hw-app-eth'

async function signTradeWithLedger(transaction) {
  const transport = await Transport.create()
  const eth = new Eth(transport)

  // Display on Ledger screen for user approval
  const signature = await eth.signTransaction(
    "44'/60'/0'/0/0", // Derivation path
    transaction.serialized
  )

  return signature
}

3.3 OpenClaw Skill Implementation

Market Search Skill

File: moltmarket-search/SKILL.md

---
name: moltmarket-search
description: Search prediction markets on Polymarket and Kalshi
version: 1.0.0
runtime: node
entrypoint: index.ts
env:
  POLYMARKET_API_KEY: required
  KALSHI_API_KEY: required
---

# MoltMarket Search

Search for prediction markets matching natural language criteria.

## Usage

Search for presidential election markets with >$1M liquidity Find Fed rate decision markets closing in next 30 days Show me high-volume technology markets

## Parameters

- `query` (string): Natural language search query
- `platforms` (array): ["polymarket", "kalshi"] or ["all"]
- `min_liquidity` (number): Minimum market liquidity in USD
- `max_close_days` (number): Markets closing within N days
- `categories` (array): Filter by category (politics, economics, tech)

## Returns

Array of markets with:
- Market ID and title
- Platform (Polymarket/Kalshi)
- Current probability
- Liquidity and 24h volume
- Close date
- Best bid/ask prices

Implementation: moltmarket-search/index.ts

import { SkillHandler } from '@openclaw/sdk'

export const handler: SkillHandler = async ({ prompt, params }) => {
  // Parse natural language query
  const searchCriteria = parseQuery(prompt)

  // Execute parallel searches
  const [polymarketResults, kalshiResults] = await Promise.all([
    searchPolymarket(searchCriteria),
    searchKalshi(searchCriteria)
  ])

  // Normalize and rank results
  const normalizedResults = normalizeMarkets([
    ...polymarketResults,
    ...kalshiResults
  ])

  return {
    markets: normalizedResults,
    count: normalizedResults.length,
    platforms: ['polymarket', 'kalshi']
  }
}

async function searchPolymarket(criteria) {
  const response = await fetch(
    `https://gamma-api.polymarket.com/markets?` +
    `limit=50&` +
    `liquidity_min=${criteria.minLiquidity}&` +
    `tag=${criteria.category}`
  )
  return response.json()
}

async function searchKalshi(criteria) {
  const response = await fetch(
    `https://trading-api.kalshi.com/trade-api/v2/markets?` +
    `limit=50&` +
    `category=${criteria.category}`,
    {
      headers: {
        'Authorization': `Bearer ${process.env.KALSHI_API_KEY}`
      }
    }
  )
  return response.json()
}

Position Opening Skill

File: moltmarket-trade/SKILL.md

---
name: moltmarket-trade
description: Open and close prediction market positions
version: 1.0.0
runtime: node
entrypoint: index.ts
env:
  MOLTMARKET_WALLET_ADDRESS: required
  MOLTMARKET_SESSION_KEY: required
  MOLTMARKET_RISK_CONFIG: required
---

# MoltMarket Trade

Execute trades on prediction markets with risk management.

## Usage

Buy $500 YES on Trump winning if probability <45% Sell $200 NO on Fed rate cut in June Open position on AI regulation market, max $300

## Risk Guardrails

- Maximum position size: $1,000 (configurable)
- Daily loss limit: $5,000 (configurable)
- Stop-loss: 35% (configurable)
- Take-profit: 65% (configurable)

## Parameters

- `market_id` (string): Market identifier
- `side` (string): "YES" or "NO"
- `amount` (number): Trade amount in USD/USDC
- `order_type` (string): "market" or "limit"
- `limit_price` (number): Limit price (0-100 for probability)
- `conditions` (object): Conditional execution rules

Implementation: moltmarket-trade/index.ts

import { SkillHandler } from '@openclaw/sdk'
import { checkRiskLimits, signTransaction } from './security'

export const handler: SkillHandler = async ({ prompt, params }) => {
  // Parse trade intent
  const trade = parseTrade(prompt, params)

  // Validate risk limits
  const riskCheck = await checkRiskLimits({
    amount: trade.amount,
    currentPositions: await getPortfolio(),
    riskConfig: loadRiskConfig()
  })

  if (!riskCheck.approved) {
    throw new Error(`Risk limit exceeded: ${riskCheck.reason}`)
  }

  // Route to appropriate platform
  let result
  if (trade.platform === 'polymarket') {
    result = await executePolymarketTrade(trade)
  } else if (trade.platform === 'kalshi') {
    result = await executeKalshiTrade(trade)
  }

  return {
    orderId: result.orderId,
    fillPrice: result.fillPrice,
    amount: result.amount,
    fees: result.fees,
    position: result.positionId
  }
}

async function executePolymarketTrade(trade) {
  // Build order payload
  const order = {
    market: trade.marketId,
    side: trade.side === 'YES' ? 'BUY' : 'SELL',
    type: trade.orderType,
    size: trade.amount,
    price: trade.limitPrice || null
  }

  // Sign transaction with session key or Ledger
  const signature = await signTransaction(order)

  // Submit to CLOB API
  const response = await fetch(
    'https://clob.polymarket.com/order',
    {
      method: 'POST',
      headers: {
        'POLY-ADDRESS': process.env.MOLTMARKET_WALLET_ADDRESS,
        'POLY-SIGNATURE': signature,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(order)
    }
  )

  return response.json()
}

3.4 Model Context Protocol (MCP) Server

For cross-framework compatibility beyond OpenClaw (LangChain, AutoGPT, CrewAI), MoltMarket implements an MCP server:

MCP Server: moltmarket-mcp/server.ts

import { Server } from '@modelcontextprotocol/sdk/server/index.js'
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
import {
  CallToolRequestSchema,
  ListToolsRequestSchema
} from '@modelcontextprotocol/sdk/types.js'

const server = new Server(
  {
    name: 'moltmarket',
    version: '1.0.0'
  },
  {
    capabilities: {
      tools: {}
    }
  }
)

// Register MCP tools
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: 'market_search',
        description: 'Search prediction markets',
        inputSchema: {
          type: 'object',
          properties: {
            query: { type: 'string' },
            platforms: { type: 'array', items: { type: 'string' } },
            min_liquidity: { type: 'number' }
          },
          required: ['query']
        }
      },
      {
        name: 'position_open',
        description: 'Open prediction market position',
        inputSchema: {
          type: 'object',
          properties: {
            market_id: { type: 'string' },
            side: { type: 'string', enum: ['YES', 'NO'] },
            amount: { type: 'number' },
            order_type: { type: 'string', enum: ['market', 'limit'] }
          },
          required: ['market_id', 'side', 'amount']
        }
      },
      // ... additional tools
    ]
  }
})

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  switch (request.params.name) {
    case 'market_search':
      return await handleMarketSearch(request.params.arguments)
    case 'position_open':
      return await handlePositionOpen(request.params.arguments)
    // ... additional handlers
  }
})

// Start server
async function main() {
  const transport = new StdioServerTransport()
  await server.connect(transport)
}

main()

MCP Client Configuration (for Claude Desktop, LangChain, etc.):

{
  "mcpServers": {
    "moltmarket": {
      "command": "node",
      "args": ["/path/to/moltmarket-mcp/server.js"],
      "env": {
        "POLYMARKET_API_KEY": "...",
        "KALSHI_API_KEY": "...",
        "MOLTMARKET_WALLET_ADDRESS": "0x..."
      }
    }
  }
}

---

4. Security & Compliance

4.1 Security Architecture

Threat Model

Primary Threats:

1. Prompt Injection: Malicious prompts trick agent into unauthorized trades

2. Private Key Compromise: Attacker gains access to wallet credentials

3. API Key Leakage: Platform API keys exposed in logs or memory

4. Phishing: Social engineering to approve malicious transactions

5. Data Exfiltration: Sensitive position data leaked to third parties

Mitigation Strategies:

1. Prompt Injection Protection

// Validate trade intent against safety rules
function validateTradeIntent(intent: TradeIntent) {
  // Block trades to unknown contracts
  if (!WHITELISTED_CONTRACTS.includes(intent.contractAddress)) {
    throw new SecurityError('Contract not whitelisted')
  }

  // Block suspicious amount patterns
  if (intent.amount === MAX_INT256) {
    throw new SecurityError('Suspicious unlimited approval')
  }

  // Verify intent matches user's natural language
  const similarity = computeSemanticSimilarity(
    intent.originalPrompt,
    intent.extractedIntent
  )
  if (similarity < 0.85) {
    throw new SecurityError('Intent mismatch detected')
  }
}

2. Hardware Wallet Integration

• Ledger Nano S/X support for transaction signing

• All transaction details displayed on device screen

• Physical button approval required

• Private keys never exposed to software

3. Session Key Sandboxing

// Session keys with limited permissions
interface SessionKey {
  publicKey: string
  privateKey: string  // Encrypted at rest
  permissions: {
    maxAmountPerTx: number      // e.g., $1,000
    maxDailyAmount: number       // e.g., $5,000
    allowedContracts: string[]   // Whitelisted addresses
    expiresAt: Date              // Auto-expire after 24h
  }
}

4. Multi-Signature for Large Trades

// Require 2-of-3 signatures for trades >$10,000
if (tradeAmount > MULTISIG_THRESHOLD) {
  const signatures = await requestMultiSigApproval({
    signers: [USER_LEDGER, BACKUP_KEY, RECOVERY_KEY],
    threshold: 2,
    trade: tradeDetails
  })
}

4.2 Regulatory Compliance

CFTC Compliance (March 2026 Guidance)

On March 12, 2026, the CFTC issued prediction market guidance establishing compliance requirements:

Core Principle 3: Designated Contract Markets (DCMs) must list only contracts "not readily susceptible to manipulation"

MoltMarket Compliance Strategy:

1. Market Selection Filtering

   • Only trade markets on CFTC-registered DCMs (Kalshi)

   • For Polymarket, filter out politically sensitive markets if trading from US

   • Exclude markets with low liquidity (<$10K) prone to manipulation

2. Audit Logging

   // Log all trades for regulatory audit
   interface TradeAuditLog {
     timestamp: Date
     agentId: string
     userId: string
     platform: 'polymarket' | 'kalshi'
     marketId: string
     side: 'YES' | 'NO'
     amount: number
     intent: string  // Original natural language prompt
     ipAddress: string
     geoLocation: string
   }

3. Geographic Restrictions

   • Respect platform geo-blocks (Kalshi: US only, Polymarket: no US frontend)

   • Detect user location via IP and enforce restrictions

   • Clear disclosures about regulatory status

4. AML/KYC Passthrough

   • Agent trades under user's verified account

   • Platform-level KYC already completed

   • No additional identity verification required by MoltMarket

Data Privacy

GDPR Compliance:

• User data stored with explicit consent

• Right to deletion (erase all position history)

• Data minimization (only store necessary trade data)

• End-to-end encryption for sensitive configuration

Data Retention:

• Trade logs: 7 years (regulatory requirement)

• API keys: Encrypted at rest, rotated every 90 days

• Position history: User-controlled deletion

4.3 Risk Management Framework

Position Limits

interface RiskConfig {
  // Per-trade limits
  maxPositionSize: number        // e.g., $1,000

  // Portfolio limits
  maxTotalExposure: number       // e.g., $10,000
  maxOpenPositions: number       // e.g., 20
  maxConcentration: number       // e.g., 30% in single market

  // Loss limits
  maxDailyLoss: number          // e.g., $5,000
  maxWeeklyLoss: number         // e.g., $15,000
  stopLossPercent: number       // e.g., 35%

  // Time restrictions
  tradingHoursOnly: boolean     // Restrict to 9am-5pm
  cooldownBetweenTrades: number // e.g., 60 seconds
}

Real-Time Risk Monitoring

async function checkRiskLimits(trade: TradeIntent): Promise<RiskCheck> {
  const portfolio = await getPortfolio()
  const config = loadRiskConfig()

  // Check position size
  if (trade.amount > config.maxPositionSize) {
    return { approved: false, reason: 'Position size exceeds limit' }
  }

  // Check total exposure
  const totalExposure = portfolio.positions.reduce(
    (sum, pos) => sum + pos.amount, 0
  )
  if (totalExposure + trade.amount > config.maxTotalExposure) {
    return { approved: false, reason: 'Total exposure limit exceeded' }
  }

  // Check daily loss limit
  const dailyPnL = calculateDailyPnL(portfolio)
  if (dailyPnL < -config.maxDailyLoss) {
    return { approved: false, reason: 'Daily loss limit hit' }
  }

  // Check concentration
  const marketExposure = portfolio.positions
    .filter(p => p.marketId === trade.marketId)
    .reduce((sum, p) => sum + p.amount, 0)
  if ((marketExposure + trade.amount) / totalExposure > config.maxConcentration) {
    return { approved: false, reason: 'Market concentration too high' }
  }

  return { approved: true }
}

---

5. Product Roadmap

Phase 1: MVP (Months 1-3)

Deliverables:

• OpenClaw skills for Polymarket integration

  • moltmarket-search - Market discovery

  • moltmarket-trade - Position opening/closing

  • moltmarket-portfolio - Portfolio monitoring

• Non-custodial wallet management with session keys

• Software wallet signing (no Ledger in MVP)

• Risk limits (position size, daily loss)

• Basic web dashboard (position tracking)

Success Metrics:

• 100+ agents installed MoltMarket skills

• $100K+ total trading volume

• <2% unauthorized trade rate

• <1 security incident

Phase 2: Kalshi Integration (Months 4-6)

Deliverables:

• Kalshi API integration (REST + WebSocket)

• Multi-platform portfolio aggregation

• Arbitrage detection across Polymarket/Kalshi

• Ledger hardware wallet support

• Enhanced dashboard with cross-platform analytics

Success Metrics:

• 50% of users trading on both platforms

• 500+ agents using MoltMarket

• $1M+ monthly trading volume

• Sub-500ms market search latency

Phase 3: Advanced Features (Months 7-12)

Deliverables:

• MCP server for cross-framework compatibility

• LangChain, AutoGPT, CrewAI providers

• Advanced strategies (market-making, event-driven)

• Backtesting framework (historical market data)

• Mobile dashboard (iOS/Android)

• API rate limit optimization (batching, caching)

Success Metrics:

• 2,000+ agents using MoltMarket

• $10M+ monthly trading volume

• Support for 3+ agent frameworks

• 99.5% uptime SLA

Phase 4: Ecosystem Expansion (Year 2)

Potential Features:

• Additional platforms (Manifold, Azuro, PredictIt)

• On-chain settlement verification (Solana smart contracts)

• Social trading (copy successful agent strategies)

• Agent marketplace (pre-built trading strategies)

• Institutional features (FIX protocol, dedicated infrastructure)

---

6. Business Model

6.1 Revenue Streams

1. Transaction Fees

• 0.5% fee on all trades executed through MoltMarket

• Applied on top of platform fees (Polymarket: 0%, Kalshi: ~2%)

• Example: $1,000 trade → $5 MoltMarket fee + $0 Polymarket fee = $5 total

2. Subscription Tiers

Free Tier:

• Up to $1,000 monthly trading volume

• Basic skills (search, trade, portfolio)

• Software wallet only

• Community support

Pro Tier ($29/month):

• Up to $50,000 monthly trading volume

• Advanced skills (arbitrage, backtesting)

• Ledger hardware wallet support

• Email support

Enterprise Tier ($299/month):

• Unlimited trading volume

• Custom risk configurations

• Multi-signature support

• Dedicated infrastructure

• Priority support + SLA

3. Data API Access

• Historical market data for backtesting

• Real-time WebSocket feeds

• Aggregated orderbook data

• Pricing: $99/month for basic, $499/month for pro

6.2 Cost Structure

Infrastructure Costs:

• API rate limits (Polymarket: free, Kalshi: metered)

• Server hosting (AWS/GCP): $500/month

• Database (PostgreSQL): $200/month

• Redis (caching): $100/month

• Monitoring (Datadog): $150/month

Development Costs:

• 2 full-time engineers: $300K/year

• 1 part-time DevOps: $75K/year

• Security audits: $50K/year

Operating Margin:

• Target: 40% gross margin at scale

• Break-even: $25K monthly revenue ($5M trading volume at 0.5% fee)

---

7. Competitive Landscape

7.1 Direct Competitors

Polystrat (Valory AG's Olas protocol)

• Autonomous AI agent for Polymarket

• 4,200+ trades, 376% returns in first month

• Polymarket-only (no Kalshi)

• Proprietary (not open-source)

• Natural language strategy definition

MoltMarket Differentiation:

• Multi-platform (Polymarket + Kalshi + future)

• OpenClaw-native (5,400+ existing skills ecosystem)

• Open-source OpenClaw skills (community contributions)

• Non-custodial with Ledger support

• Cross-framework MCP server

Polymarket Official AI Agents GitHub (github.com/Polymarket/agents)

• Official Polymarket AI agent framework

• Python-based, LangChain integration

• Open-source

• Polymarket-only

MoltMarket Differentiation:

• Multi-platform support

• OpenClaw ecosystem integration

• TypeScript + Python support

• Enterprise security features (Ledger, multi-sig)

7.2 Indirect Competitors

Traditional Trading Bots (TradingView, 3Commas)

• Focus on crypto/stock markets, not prediction markets

• No AI agent integration

• No natural language interface

Agent Frameworks (LangChain, AutoGPT)

• General-purpose agent frameworks

• Require custom code for prediction markets

• No pre-built skills for Polymarket/Kalshi

MoltMarket Position: Vertical integration for prediction market trading with AI agents.

---

8. Technical Risks & Mitigation

8.1 API Dependency Risk

Risk: Platform API changes break MoltMarket integration

Mitigation:

• Maintain adapter pattern with versioned API clients

• Monitor API changelogs and deprecation notices

• Automated integration tests against live APIs

• Fallback to backup endpoints if primary fails

8.2 Security Vulnerabilities

Risk: Prompt injection or key compromise leads to unauthorized trades

Mitigation:

• Mandatory Ledger approval for large trades (>$1,000)

• Semantic validation of trade intent vs. prompt

• Smart contract spending limits (on-chain enforcement)

• Regular security audits by third-party firms

• Bug bounty program for vulnerability disclosure

8.3 Regulatory Risk

Risk: CFTC restricts AI agent trading or imposes new compliance requirements

Mitigation:

• Monitor CFTC guidance (current ANPRM comment period until April 30, 2026)

• Design for compliance: audit logs, geo-restrictions, KYC passthrough

• Focus on Kalshi (regulated DCM) for US users

• Legal counsel on retainer for regulatory changes

8.4 Platform Risk

Risk: Polymarket or Kalshi restricts API access or bans automated trading

Mitigation:

• Multi-platform strategy (not dependent on single platform)

• Comply with platform ToS (no wash trading, manipulation)

• Rate limiting and respectful API usage

• Relationship building with platform teams

8.5 Market Risk

Risk: Prediction market trading volume declines, reducing MoltMarket usage

Mitigation:

• Expand to additional platforms (diversification)

• Non-trading features (analytics, backtesting) provide value regardless of volume

• Build for institutional use cases (hedge funds, research firms)

---

9. Success Metrics

9.1 Product Metrics

Adoption:

• OpenClaw skill installations (target: 2,000 in Year 1)

• Active agents per month (target: 500 in Year 1)

• Monthly trading volume (target: $10M in Year 1)

Engagement:

• Trades per agent per month (target: 25)

• Portfolio value managed (target: $5M AUM in Year 1)

• Skill usage frequency (target: 80% weekly active)

Performance:

• Market search latency p95 (target: <500ms)

• Trade execution success rate (target: >95%)

• Position fill rate (target: >90%)

• System uptime (target: 99.5%)

9.2 Business Metrics

Revenue:

• Monthly recurring revenue (target: $50K in Year 1)

• Transaction fee revenue (target: $25K/month in Year 1)

• Subscription revenue (target: $25K/month in Year 1)

Costs:

• Customer acquisition cost (target: <$100)

• Gross margin (target: 40%)

• Burn rate (target: <$50K/month)

9.3 Security Metrics

Safety:

• Unauthorized trade rate (target: <1%)

• Security incidents (target: 0 critical incidents)

• False positive risk blocks (target: <5%)

---

10. Technical Stack Summary

10.1 Core Technologies

Component	Technology	Justification
Agent Framework	OpenClaw	247K GitHub stars, 5,400+ skills ecosystem, viral adoption
Language	TypeScript 5.7+	Type safety, OpenClaw plugin compatibility
Runtime	Node.js 18+	OpenClaw skill runtime, async I/O
Blockchain	Polygon (Polymarket)	Layer 2 Ethereum, low fees, USDC collateral
Wallet	Ledger (hardware) + ethers.js (software)	Non-custodial security
API Protocol	MCP (Model Context Protocol)	Cross-framework compatibility
Web Framework	Next.js 15 App Router	Server-side rendering, API routes, React
Styling	Tailwind CSS 4.x	Utility-first, JIT compilation
Database	PostgreSQL	Relational data (positions, trades, audit logs)
Caching	Redis	WebSocket subscriptions, rate limiting
Testing	Jest + React Testing Library	Unit and integration tests
Monitoring	Prometheus + Grafana	Metrics, alerts, dashboards

10.2 Development Tools

Package Management: npm Version Control: Git + GitHub CI/CD: GitHub Actions Deployment: Docker + Kubernetes (production), Vercel (web dashboard) Documentation: GitBook (docs), JSDoc (code)

---

11. Conclusion

MoltMarket addresses a critical gap in the autonomous agent ecosystem: enabling natural language prediction market trading with enterprise-grade security. By building on the OpenClaw platform (247K GitHub stars, 5,400+ skills) and integrating with leading prediction markets (Polymarket, Kalshi), MoltMarket positions itself as the definitive integration layer for AI-powered prediction market trading.

Key Differentiators:

1. OpenClaw-Native: Plugs into the fastest-growing agent ecosystem

2. Multi-Platform: Polymarket + Kalshi + future platforms

3. Non-Custodial Security: Ledger integration, session keys, smart contract guardrails

4. Regulatory Compliance: CFTC guidance adherence, audit logging, geo-restrictions

5. Cross-Framework: MCP server for LangChain, AutoGPT, CrewAI

Market Opportunity: With prediction markets reaching $50B+ trading volume and AI agents demonstrating superior trading performance (Polystrat: 376% returns), MoltMarket is positioned to capture a significant share of autonomous agent trading activity.

Next Steps:

1. Develop MVP OpenClaw skills (Polymarket integration)

2. Security audit by third-party firm

3. Beta launch with 50 early adopter agents

4. Publish ClawHub registry listing

5. Kalshi integration and cross-platform features

---

Sources & References

OpenClaw Research:

• OpenClaw Explained - KDnuggets

• How OpenClaw Works - Medium

• OpenClaw Skills Documentation

• Awesome OpenClaw Skills - GitHub

Prediction Market APIs:

• Polymarket API Documentation

• Kalshi API Documentation

• The Polymarket API - Medium

• Polymarket Official AI Agents - GitHub

AI Agents in Prediction Markets:

• AI Agents Are Quietly Rewriting Prediction Market Trading - CoinDesk

• IOSG: Prediction Market Agents - KuCoin

Wallet Security:

• Introducing Agentic Wallets - Coinbase

• MoonPay Ledger-Secured AI Agents - CoinDesk

• AI Agents That Spend Crypto - AurPay

Regulatory Compliance:

• CFTC Issues Prediction Markets Advisory

• Federal Register: Prediction Markets

• CFTC Takes Additional Steps - Crowell & Moring

Blockchain Infrastructure:

• Prediction Market Smart Contracts - Solana - GitHub

• Building Prediction Markets on Solana - DEV Community

---

Document Version: 1.0 Last Updated: March 19, 2026 Author: MoltMarket Research Team Status: Concept Brief - Technical Architecture Defined