Supported Markets

Understanding the prediction market platforms integrated with the agent framework

Overview

The Gnosis Prediction Market Agent framework supports four major prediction market platforms. Each platform has unique characteristics, market types, and trading mechanisms.

Market Platforms

Omen (Presagio)

Decentralized prediction markets on Gnosis Chain

Polymarket

High-liquidity crypto prediction markets

Manifold

Play-money prediction markets with high volume

Metaculus

Forecasting tournaments and community predictions

MarketType Enum

Specify which platform to use when running your agent:

from prediction_market_agent_tooling.markets.markets import MarketType

# Available market types
MarketType.OMEN       # Omen/Presagio on Gnosis Chain
MarketType.POLYMARKET # Polymarket
MarketType.MANIFOLD   # Manifold Markets
MarketType.METACULUS  # Metaculus

Running Agents on Different Platforms

When running your agent, specify the market type as a command-line argument:

Omen

python prediction_market_agent/run_agent.py coinflip omen

Platform Comparison

Platform	Currency	Blockchain	Market Types	Best For
Omen	xDAI, USDC	Gnosis Chain	Binary, Categorical, Scalar	Decentralized trading, low fees
Polymarket	USDC	Polygon	Binary	High liquidity, real-money trading
Manifold	Mana (play money)	Off-chain	Binary, Multiple choice	Testing, experimentation, high volume
Metaculus	Points	Off-chain	Binary, Continuous	Forecasting tournaments, research

The AgentMarket Interface

All market platforms expose a unified AgentMarket interface:

class AgentMarket:
    id: str                    # Unique market identifier
    question: str              # The question being predicted
    outcomes: list[str]        # Possible outcomes
    p_yes: Probability         # Current probability of YES
    p_no: Probability          # Current probability of NO
    volume: float             # Total trading volume
    close_time: DatetimeUTC   # When the market closes
    total_liquidity: float    # Available liquidity
    
    def get_trade_balance(self, api_keys: APIKeys) -> USD:
        """Get available balance for trading"""
        ...
    
    def place_bet(self, amount: USD, outcome: bool) -> None:
        """Place a bet on this market"""
        ...

Platform-Specific Features

Omen (Presagio)

Key Features

• Fully decentralized on Gnosis Chain
• Support for binary, categorical, and scalar markets
• On-chain settlement via Reality.eth oracle
• GraphQL API for market data
• Low transaction fees (~$0.01)

Market Discovery

from prediction_market_agent_tooling.markets.omen.omen_subgraph_handler import (
    OmenSubgraphHandler,
    SortBy,
    FilterBy,
)

# Fetch Omen markets
handler = OmenSubgraphHandler()
markets = handler.get_omen_markets_simple(
    limit=10,
    sort_by=SortBy.CLOSING_SOONEST,
    filter_by=FilterBy.OPEN,
)

Required API Keys

.env

BET_FROM_PRIVATE_KEY=0x...  # Private key for trading wallet

Polymarket

Key Features

• High liquidity and trading volume
• Real money (USDC) trading
• Wide range of topics (politics, crypto, sports)
• CLOB (Central Limit Order Book) trading
• Historical market data via GraphQL

Agent Example

The Berlin1PolySentAgent uses sentiment analysis and historical data:

class Berlin1PolySentAgent(DeployableTraderAgent):
    def answer_binary_market(self, market: AgentMarket) -> ProbabilisticAnswer | None:
        # Search for information
        urls = search_google_serper(market.question)
        contents = scrape_and_split_urls(urls)
        
        # Extract sentiment
        sentiment = extract_sentiment(contents)
        
        # Get Polymarket history
        history_data = get_polymarket_history(market.question)
        history_summary = summarize_history(history_data)
        
        # Generate prediction
        probability, confidence = llm(
            market.question, contents, history_summary, sentiment
        )
        
        return ProbabilisticAnswer(
            confidence=confidence,
            p_yes=Probability(probability),
        )

Manifold Markets

Key Features

• Play money (Mana) - no real money risk
• High volume of diverse markets
• Fast iteration and experimentation
• Community-driven questions
• Ideal for testing agent strategies

Best Practices

• Filter out self-referential markets (markets about Manifold itself)
• Use for testing before deploying to real-money platforms
• High volume means more opportunities to trade
• Lower stakes mean higher risk tolerance

Metaculus

Key Features

• Tournament-style forecasting competitions
• Point-based reputation system
• Expert forecaster community
• Questions often have longer time horizons
• Emphasis on calibration and accuracy

Specialized Agent

The Metaculus bot tournament agent targets specific competitions:

class DeployableMetaculusBotTournamentAgent(DeployableTraderAgent):
    supported_markets = [MarketType.METACULUS]
    
    def get_markets(
        self,
        market_type: MarketType,
    ) -> Sequence[AgentMarket]:
        # Fetch tournament-specific markets
        return get_tournament_markets(
            sort_by=SortBy.NEWEST,
        )

Market Sorting and Filtering

SortBy Options

from prediction_market_agent_tooling.markets.agent_market import SortBy

class MyAgent(DeployableTraderAgent):
    # Choose your sorting preference
    get_markets_sort_by = SortBy.CLOSING_SOONEST  # Default
    # get_markets_sort_by = SortBy.HIGHEST_LIQUIDITY
    # get_markets_sort_by = SortBy.NEWEST
    # get_markets_sort_by = SortBy.NONE

SortBy.CLOSING_SOONEST

Prioritize markets that close soon. Good for:

• Capturing value before resolution
• Time-sensitive predictions
• Maximizing capital efficiency

SortBy.HIGHEST_LIQUIDITY

Target markets with most liquidity. Good for:

• Minimizing price impact
• Larger bet sizes
• More efficient trading

class GPTRHighestLiquidityAgent(GPTRAgent):
    get_markets_sort_by = SortBy.HIGHEST_LIQUIDITY
    bet_on_n_markets_per_run = 2

SortBy.NEWEST

Focus on newly created markets. Good for:

• Capturing early mispricings
• Markets starting at 50/50
• First-mover advantage

class SkewAgent(DeployableTraderAgent):
    get_markets_sort_by = SortBy.NEWEST
    bet_on_n_markets_per_run = 1000

Limiting to Specific Platforms

Restrict your agent to certain platforms:

from prediction_market_agent_tooling.markets.markets import MarketType

class OmenOnlyAgent(DeployableTraderAgent):
    supported_markets = [MarketType.OMEN]
    
    # This agent will only run on Omen markets

Custom Market Selection

For advanced use cases, override market selection entirely:

class MarketCreatorsStalkerAgent(DeployableTraderAgent):
    """Only bet on markets from specific creators"""
    
    WHITELISTED_CREATORS = [
        Web3.to_checksum_address("0xa7E93F5A0e718bDDC654e525ea668c64Fd572882"),
    ]
    
    def get_markets(
        self,
        market_type: MarketType,
        sort_by: SortBy = SortBy.CLOSING_SOONEST,
        filter_by: FilterBy = FilterBy.OPEN,
    ) -> Sequence[OmenAgentMarket]:
        return [
            OmenAgentMarket.from_data_model(m)
            for m in OmenSubgraphHandler().get_omen_markets_simple(
                limit=self.n_markets_to_fetch,
                sort_by=sort_by,
                filter_by=filter_by,
                creator_in=self.WHITELISTED_CREATORS,
            )
        ]

Market Data and Analytics

Access market information in your predictions:

def answer_binary_market(self, market: AgentMarket) -> ProbabilisticAnswer | None:
    # Check market properties
    if market.volume < 1000:
        logger.info(f"Skipping low-volume market: {market.question}")
        return None
    
    if market.total_liquidity < 100:
        logger.info(f"Insufficient liquidity: {market.question}")
        return None
    
    # Check time until close
    time_until_close = market.close_time - utcnow()
    if time_until_close < timedelta(hours=1):
        logger.info(f"Market closing too soon: {market.question}")
        return None
    
    # Current market prices
    logger.info(f"Current price: YES={market.p_yes}, NO={market.p_no}")
    
    # Your prediction logic here
    ...

Multi-Platform Strategies

Some agents work across all platforms, while others are specialized. Design your agent based on your goals:

• Universal agents: Test on Manifold, deploy to Omen/Polymarket
• Platform-specific: Optimize for one platform’s unique features
• Arbitrage agents: Monitor prices across multiple platforms

Next Steps

Agent Architecture

Build your first trading agent

Betting Strategies

Learn about Kelly criterion and bet sizing