How to Build an AI Trading Bot for Polymarket

An AI bot called "ilovecircle" made $2.2 million in just two months on Polymarket with a 74% win rate. This guide covers how AI agents trade prediction markets, the official Polymarket/agents framework, and how to build your own LLM-powered trading bot.

The ilovecircle Bot: $2.2M Case Study

The most successful documented AI bot on Polymarket generated massive profits using a neural network approach:

How It Works

1. Neural network evaluates potential outcomes across markets
2. Continuously analyzes news, on-chain data, and whale flows
3. Identifies underpriced opportunities
4. Executes trades via Polymarket API
5. Dynamically adjusts strategy every few minutes

Polymarket/agents: Official Framework

Polymarket maintains an official open-source framework for building AI trading agents:

Key Components

• cli.py: Primary interface for API, news, LLMs, and trades
• gamma.py: GammaMarketClient for market metadata
• chroma.py: Vector database for RAG-based analysis
• Modular architecture: Extend with custom data sources

Installation

# Clone the repo
git clone https://github.com/Polymarket/agents
cd agents

# Install dependencies
pip install -r requirements.txt

# Key dependencies installed:
# - py-clob-client (Polymarket API)
# - langchain (LLM framework)
# - chromadb (vector database)
# - python-order-utils (order signing)

AI Bot Architecture

A successful AI trading agent has five core components:

LLM-Based Trading Strategies

Multi-LLM Ensemble

Top AI bots use multiple LLMs for consensus predictions:

• ChatGPT for broad reasoning
• Claude for nuanced analysis
• DeepSeek for technical patterns
• Gemini for news processing
• Grok for Twitter/X sentiment

RAG (Retrieval-Augmented Generation)

Vector databases enable context-aware market analysis:

from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma

# Index news and market data
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(
    documents=news_articles,
    embedding=embeddings
)

# Query relevant context for market analysis
relevant_docs = vectorstore.similarity_search(
    "What is the latest news about Bitcoin ETF approval?",
    k=5
)

See What Whales Are Trading Right Now

Get instant alerts when top traders make moves. Track P&L, win rates, and copy winning strategies.

Free forever. No credit card required.

Data Sources for AI Bots

1. News & Information

• NewsAPI for real-time news feeds
• RSS feeds from major outlets
• Breaking news monitoring

2. Social Sentiment

• Twitter/X sentiment analysis
• Reddit discussion monitoring
• Crypto influencer tracking (400+ accounts)

3. On-Chain Analytics

• Smart wallet flow monitoring
• CoinGecko trending tokens
• Polygonscan transaction data

4. Polymarket APIs

• GraphQL subgraphs for positions/history
• Gamma API for market metadata
• WebSocket for real-time prices
• CLOB API for order book

Building Your AI Agent

Step 1: Set Up py-clob-client

from py_clob_client.client import ClobClient

# Read-only client (no auth needed)
client = ClobClient(host="https://clob.polymarket.com")

# Get market data
markets = client.get_markets()
midpoint = client.get_midpoint(token_id)
order_book = client.get_order_book(token_id)

Step 2: Create LLM Analyzer

from langchain.chat_models import ChatOpenAI
from langchain.prompts import PromptTemplate

llm = ChatOpenAI(model="gpt-4", temperature=0)

analysis_prompt = PromptTemplate(
    input_variables=["market_question", "news", "current_price"],
    template="""
    Analyze this prediction market:
    Question: {market_question}
    Current YES price: {current_price}

    Recent news:
    {news}

    Estimate the true probability (0-100%) and explain your reasoning.
    """
)

def analyze_market(market, news):
    response = llm.predict(
        analysis_prompt.format(
            market_question=market['question'],
            news=news,
            current_price=market['price']
        )
    )
    return extract_probability(response)

Step 3: Calculate Expected Value

def calculate_expected_value(true_prob, market_price, side="YES"):
    """
    Calculate expected value of a trade.

    If true_prob > market_price for YES, there's +EV
    If true_prob < market_price for YES, bet NO instead
    """
    if side == "YES":
        # Profit if win: (1 - price), Loss if lose: price
        ev = (true_prob * (1 - market_price)) - ((1 - true_prob) * market_price)
    else:
        # Betting NO
        ev = ((1 - true_prob) * (1 - market_price)) - (true_prob * market_price)

    return ev

def should_trade(true_prob, market_price, min_edge=0.05):
    """Only trade if edge > 5%"""
    if true_prob > market_price + min_edge:
        return "BUY_YES", true_prob - market_price
    elif true_prob < market_price - min_edge:
        return "BUY_NO", market_price - true_prob
    return None, 0

Step 4: Position Sizing (Kelly Criterion)

def kelly_criterion(true_prob, market_price, bankroll, fraction=0.25):
    """
    Calculate optimal position size using Kelly Criterion.
    Use fractional Kelly (0.25) for safety.
    """
    # Kelly formula: f* = (bp - q) / b
    # b = odds received on bet (1/price - 1)
    # p = probability of winning
    # q = probability of losing (1-p)

    b = (1 / market_price) - 1
    p = true_prob
    q = 1 - p

    kelly = (b * p - q) / b

    # Apply fractional Kelly and max position limit
    position_size = max(0, kelly * fraction * bankroll)
    max_position = bankroll * 0.10  # Never risk more than 10%

    return min(position_size, max_position)

Step 5: Execute Trades

from py_clob_client.client import ClobClient
from py_clob_client.clob_types import OrderType

# Authenticated client for trading
client = ClobClient(
    host="https://clob.polymarket.com",
    key="YOUR_PRIVATE_KEY",
    chain_id=137
)

def execute_trade(token_id, side, size, price):
    """Place a limit order on Polymarket"""
    order = client.create_order(
        token_id=token_id,
        price=price,
        side=side,
        size=size
    )

    result = client.post_order(order, OrderType.GTC)
    return result

Claude MCP Integration

Several Model Context Protocol (MCP) servers enable Claude to trade Polymarket directly:

Performance Benchmarks

Risk Management

Capital Requirements

• Testing: $1,000-3,000 for strategy validation
• Small-scale: $10,000 starting capital
• Medium-scale: $10,000-100,000 for meaningful profits
• Infrastructure: $50-200/month hosting + $100-1,000 LLM APIs

Risk Controls

• Position limits: Never risk >10% on single market
• Daily loss limit: Stop if down 5% in a day
• Kelly fraction: Use 0.25x Kelly, not full
• Diversification: Spread across uncorrelated markets

Open Source Resources

Official Polymarket Repos

• Polymarket/agents: Official AI agent framework
• Polymarket/py-clob-client: Python CLOB client
• Polymarket/clob-client: TypeScript client
• Polymarket/real-time-data-client: WebSocket client

Community Bots

• BlackSky-Jose/PolyMarket-trading-AI-model: LangChain + FastAPI
• llSourcell/Poly-Trader: Autonomous agent implementation
• Trust412/Polymarket-spike-bot-v1: High-frequency spike detection
• posimer/polymarket-ai-market-suggestor: AI market discovery

Why AI Has an Edge

According to market makers on Polymarket:

"The space is incredibly underdeveloped compared to traditional crypto markets. In DeFi you have sophisticated market makers with millions in capital. On Polymarket it's mostly individual traders clicking buttons. That creates massive opportunities for anyone willing to build proper systems."

• Speed: Millisecond reactions vs human seconds/minutes
• Scale: Monitor hundreds of markets simultaneously
• Consistency: No emotions, FOMO, or fatigue
• 24/7: Continuous operation without breaks

Getting Started Checklist

1. Clone github.com/Polymarket/agents
2. Set up py-clob-client with read-only access
3. Integrate an LLM (GPT-4, Claude, etc.)
4. Build a simple probability estimator
5. Paper trade for 2-4 weeks
6. Start with $1,000-3,000 live capital
7. Implement strict risk controls
8. Monitor and iterate on your strategy