Max Accuracy Strategies

Overview

Max accuracy betting strategies prioritize prediction accuracy over profit maximization. These strategies are ideal for tournaments, reputation building, benchmarking, and situations where accuracy metrics matter more than monetary returns.

Use accuracy-focused strategies when optimizing for prediction quality, Brier scores, or leaderboard rankings rather than maximizing profits.

When to Use

Choose max accuracy strategies when:

Participating in prediction tournaments or competitions
Building reputation on prediction platforms
Benchmarking model performance
Testing prediction quality with minimal capital risk
Optimizing for accuracy metrics (e.g., Brier score, calibration)

Accuracy strategies may underperform profit-maximizing strategies like Kelly in terms of monetary returns.

CategoricalMaxAccuracyBettingStrategy

Minimalist betting strategy that focuses purely on prediction accuracy. Works for both binary and categorical markets.

Import

from prediction_market_agent_tooling.deploy.betting_strategy import (
    CategoricalMaxAccuracyBettingStrategy,
)
from prediction_market_agent_tooling.gtypes import USD

Usage

from prediction_market_agent_tooling.deploy.agent import DeployableTraderAgent
from prediction_market_agent_tooling.markets.agent_market import AgentMarket

class AccuracyAgent(DeployableTraderAgent):
    def get_betting_strategy(self, market: AgentMarket) -> BettingStrategy:
        return CategoricalMaxAccuracyBettingStrategy(
            max_position_amount=USD(1.0),
        )

Parameters

max_position_amount

USD

required

Maximum amount to bet on a single position.Common patterns:

USD(0.01) - Minimal capital risk, maximum number of predictions
USD(1.0) - Standard accuracy testing
balance / 100 - Ensure at least 100 predictions for statistical significance
USD(5.0)+ - Higher stakes accuracy competitions

How It Works

The strategy:

Places small, consistent bets regardless of odds or edge
Bets on the outcome with highest predicted probability
Uses uniform position sizing for clean accuracy metrics
Prioritizes making predictions on many markets

For statistical validity, aim for at least 30-100 predictions. Use balance / 100 to ensure sufficient market coverage.

Real-World Examples

SkewAgent (Volume Strategy)

Divides bankroll across 100+ tiny bets to leverage statistical patterns:

class SkewAgent(DeployableTraderAgent):
    # Process up to 1000 markets
    n_markets_to_fetch = 1000
    bet_on_n_markets_per_run = 1000
    
    def get_betting_strategy(self, market: AgentMarket) -> BettingStrategy:
        # Ensure at least 100 trades for statistics
        max_position_amount = max(
            USD(0.01),  # Minimum $0.01 per bet
            market.get_trade_balance(self.api_keys) / 100
        )
        return CategoricalMaxAccuracyBettingStrategy(
            max_position_amount=max_position_amount,
        )

Use case: Exploiting market-wide skew patterns (e.g., “Yes” outcomes are more common) with minimal capital risk per prediction.Location: prediction_market_agent/agents/skew_agent/deploy.py:79

DeployablePredictionProphetDeepSeekR1

Uses accuracy strategy for DeepSeek R1 model testing:

class DeployablePredictionProphetDeepSeekR1(DeployableTraderAgent):
    model = "deepseek/deepseek-r1"
    
    def get_betting_strategy(self, market: AgentMarket) -> BettingStrategy:
        return CategoricalMaxAccuracyBettingStrategy(
            max_position_amount=get_maximum_possible_bet_amount(
                min_=USD(1),
                max_=USD(6.5),
                trading_balance=market.get_trade_balance(APIKeys()),
            )
        )

Use case: Testing a new model’s prediction accuracy with moderate position sizes before committing to profit-maximizing strategies.Location: prediction_market_agent/agents/prophet_agent/deploy.py:390

MaxAccuracyWithKellyScaledBetsStrategy

Hybrid strategy that optimizes for accuracy while scaling bet sizes using Kelly criterion principles. Combines the best of both approaches.

Import

from prediction_market_agent_tooling.deploy.betting_strategy import (
    MaxAccuracyWithKellyScaledBetsStrategy,
)

Usage

class HybridAgent(DeployableTraderAgent):
    def get_betting_strategy(self, market: AgentMarket) -> BettingStrategy:
        return MaxAccuracyWithKellyScaledBetsStrategy(
            max_position_amount=USD(5.0),
        )

Parameters

max_position_amount

USD

required

Maximum amount to bet on a single position. Kelly scaling will adjust bets below this limit based on edge and confidence.

How It Works

This strategy:

Identifies the outcome with highest predicted accuracy
Scales bet size using Kelly-inspired calculations
Accounts for edge magnitude (how much your prediction differs from market)
Caps bets at max_position_amount

Benefits over CategoricalMaxAccuracy:

Variable bet sizing based on conviction
Better capital efficiency
Still optimizes for accuracy metrics
Reduces risk on uncertain predictions

Benefits over pure Kelly:

Maintains focus on accuracy over pure profit
More conservative bet sizing
Better for reputation and leaderboards

Real-World Example

Berlin2OpenaiSearchAgentVariable

Uses OpenAI’s search API with o3-mini reasoning, optimized for accuracy with Kelly scaling:

from openai import OpenAI
from prediction_market_agent_tooling.deploy.agent import DeployableTraderAgent
from prediction_market_agent_tooling.deploy.betting_strategy import (
    BettingStrategy,
    MaxAccuracyWithKellyScaledBetsStrategy,
)
from prediction_market_agent.agents.utils import get_maximum_possible_bet_amount

class Berlin2OpenaiSearchAgentVariable(DeployableTraderAgent):
    bet_on_n_markets_per_run = 2

    def get_betting_strategy(self, market: AgentMarket) -> BettingStrategy:
        return MaxAccuracyWithKellyScaledBetsStrategy(
            max_position_amount=get_maximum_possible_bet_amount(
                min_=USD(1),
                max_=USD(6),
                trading_balance=market.get_trade_balance(self.api_keys),
            ),
        )

    def answer_binary_market(self, market: AgentMarket) -> ProbabilisticAnswer | None:
        # Uses gpt-4o for research + o3-mini for reasoning
        # ... implementation details ...
        return ProbabilisticAnswer(
            confidence=confidence,
            p_yes=Probability(probability),
        )

Location: prediction_market_agent/agents/berlin2_agent/openai_search_agent_variable.py:19 Use case: Two-stage prediction pipeline (research + reasoning) where accuracy matters but bet sizing should reflect confidence levels.

This agent combines GPT-4o’s research capabilities with o3-mini’s reasoning, using accuracy-focused betting with Kelly scaling.

Strategy Comparison

CategoricalMaxAccuracyBettingStrategy

Best for:

Pure accuracy metrics
High-volume prediction strategies
Statistical analysis (uniform bet sizing)
Minimal capital risk
Testing new models

Characteristics:

Uniform bet sizing
Simple implementation
Maximum number of predictions
Clean accuracy measurement

Example use:

# Make 100+ predictions with minimal risk each
max_position = market.balance / 100
return CategoricalMaxAccuracyBettingStrategy(
    max_position_amount=max(USD(0.01), max_position)
)

MaxAccuracyWithKellyScaledBetsStrategy

Best for:

Accuracy optimization with variable confidence
Reputation building with better capital efficiency
Competitions where both accuracy and returns matter
Moderate risk tolerance

Characteristics:

Variable bet sizing
Kelly-inspired scaling
Better capital efficiency
Accounts for edge magnitude

Example use:

# Scale bets 1-6 USD based on confidence and edge
return MaxAccuracyWithKellyScaledBetsStrategy(
    max_position_amount=get_maximum_possible_bet_amount(
        min_=USD(1),
        max_=USD(6),
        trading_balance=balance,
    )
)

Kelly Betting (for comparison)

Best for:

Maximizing long-term growth
Profit optimization
Production deployment
Risk-managed betting

Characteristics:

Optimal growth rate
Large bets on big edges
Automatically protects bankroll
May sacrifice accuracy metrics

Example use:

# Optimize for profit, not accuracy
return FullBinaryKellyBettingStrategy(
    max_position_amount=USD(10),
    max_price_impact=0.7,
)

Accuracy Metrics

When using accuracy strategies, track these metrics:

Brier Score

# Lower is better (0 = perfect predictions, 1 = worst)
import numpy as np

def brier_score(predictions: list[float], outcomes: list[bool]) -> float:
    """Calculate Brier score for probabilistic predictions."""
    return np.mean([(p - int(o)) ** 2 for p, o in zip(predictions, outcomes)])

# Example
predictions = [0.7, 0.4, 0.9, 0.5]
outcomes = [True, False, True, True]
score = brier_score(predictions, outcomes)  # Lower is better

Accuracy Rate

def accuracy_rate(predictions: list[float], outcomes: list[bool]) -> float:
    """Simple accuracy: did the higher probability outcome occur?"""
    correct = sum(1 for p, o in zip(predictions, outcomes)
                  if (p > 0.5 and o) or (p <= 0.5 and not o))
    return correct / len(predictions)

Calibration

For CategoricalMaxAccuracy with uniform bets, check if your predicted probabilities match actual outcomes:

# Example: predictions at 0.7 should resolve True ~70% of the time
# Perfect calibration means predicted probabilities match empirical frequencies

Aim for at least 30-100 predictions before evaluating accuracy metrics for statistical significance.

Integration Patterns

Testing Then Optimizing

Start with accuracy strategy, migrate to profit optimization:

class EvolvingAgent(DeployableTraderAgent):
    testing_mode: bool = True  # Set via config
    
    def get_betting_strategy(self, market: AgentMarket) -> BettingStrategy:
        if self.testing_mode:
            # Test accuracy with minimal risk
            return CategoricalMaxAccuracyBettingStrategy(
                max_position_amount=USD(0.5),
            )
        else:
            # Optimize for profit after validation
            return FullBinaryKellyBettingStrategy(
                max_position_amount=USD(5.0),
                max_price_impact=0.7,
            )

Confidence-Based Strategy Selection

Use different strategies based on prediction confidence:

class AdaptiveAgent(DeployableTraderAgent):
    def get_betting_strategy(self, market: AgentMarket) -> BettingStrategy:
        # This will be called before betting, so confidence from
        # answer_binary_market can be used in custom logic
        return MaxAccuracyWithKellyScaledBetsStrategy(
            max_position_amount=USD(5.0),
        )
    
    def answer_binary_market(self, market: AgentMarket) -> ProbabilisticAnswer | None:
        answer = self.make_prediction(market)
        
        # Could extend to choose strategy based on confidence
        # But note: get_betting_strategy is called once per market
        
        return answer

Volume Strategy

Optimize for maximum predictions with minimal capital per bet:

class VolumeAgent(DeployableTraderAgent):
    n_markets_to_fetch = 1000
    bet_on_n_markets_per_run = 1000
    
    def get_betting_strategy(self, market: AgentMarket) -> BettingStrategy:
        # Ensure 100+ predictions possible
        balance = market.get_trade_balance(self.api_keys)
        max_bet = max(USD(0.01), balance / 100)
        
        return CategoricalMaxAccuracyBettingStrategy(
            max_position_amount=max_bet,
        )

Best Practices

Define Your Goal

Clarify whether you’re optimizing for:

Accuracy metrics (Brier score, calibration)
Leaderboard ranking
Model benchmarking
Reputation building

Choose Appropriate Strategy

Pure accuracy focus: CategoricalMaxAccuracyBettingStrategy
Accuracy + efficiency: MaxAccuracyWithKellyScaledBetsStrategy

Set Position Sizes

For statistical validity:

# Aim for 100+ predictions
max_position = max(USD(0.01), balance / 100)

Track Metrics

Log predictions and outcomes to calculate:

Brier score
Accuracy rate
Calibration
Profit/loss (even if not primary goal)

Consider Migration

Once accuracy is validated, consider migrating to Kelly betting for better returns:

# After proving accuracy, optimize for profit
return FullBinaryKellyBettingStrategy(...)

Limitations

Accuracy strategies deliberately sacrifice profit potential for prediction quality.

Lower Expected Returns

Uniform or conservative bet sizing means you won’t fully capitalize on large edges. Expected profits are lower than Kelly strategies.

Capital Inefficiency

Small fixed bets tie up capital that could be earning more in Kelly-optimized strategies. Opportunity cost can be significant.

May Not Win Profit Leaderboards

If the competition ranks by total profit, accuracy strategies will underperform aggressive Kelly betting.

Requires Volume

Need many predictions (30-100+) for meaningful accuracy metrics. Not suitable for low-volume strategies.

When to Switch Strategies

Migrate from accuracy to profit optimization when:

Validated accuracy: You’ve demonstrated good prediction quality (e.g., Brier score < 0.15)
Sufficient data: You have 50-100+ predictions showing consistent performance
Going to production: Moving from testing to real capital deployment
Competition focus changes: Tournament shifts from accuracy to profit rankings

# Migration example
# Before (testing)
return CategoricalMaxAccuracyBettingStrategy(
    max_position_amount=USD(0.5),
)

# After (production)
return FullBinaryKellyBettingStrategy(
    max_position_amount=USD(5.0),
    max_price_impact=0.7,
)

Kelly Betting Strategies

Profit-optimizing strategies for production use

Max Expected Value

Maximize expected returns per bet

Betting Strategies Concept

Learn betting strategy fundamentals

Benchmarking Guide

How to benchmark and evaluate agent performance

Core Classes

Agent Implementations

Markets

Betting Strategies

Tools

Overview

When to Use

CategoricalMaxAccuracyBettingStrategy

Import

Usage

Parameters

How It Works

Real-World Examples

MaxAccuracyWithKellyScaledBetsStrategy

Import

Usage

Parameters

How It Works

Real-World Example

Berlin2OpenaiSearchAgentVariable

Strategy Comparison

Accuracy Metrics

Brier Score

Accuracy Rate

Calibration

Integration Patterns

Testing Then Optimizing

Confidence-Based Strategy Selection

Volume Strategy

Best Practices

Limitations

When to Switch Strategies

See Also

Kelly Betting Strategies

Max Expected Value

Betting Strategies Concept

Benchmarking Guide

Build docs developers (and LLMs) love

Core Classes

Agent Implementations

Markets

Betting Strategies

Tools

​Overview

​When to Use

​CategoricalMaxAccuracyBettingStrategy

​Import

​Usage

​Parameters

​How It Works

​Real-World Examples

​MaxAccuracyWithKellyScaledBetsStrategy

​Import

​Usage

​Parameters

​How It Works

​Real-World Example

​Berlin2OpenaiSearchAgentVariable

​Strategy Comparison

​Accuracy Metrics

​Brier Score

​Accuracy Rate

​Calibration

​Integration Patterns

​Testing Then Optimizing

​Confidence-Based Strategy Selection

​Volume Strategy

​Best Practices

​Limitations

​When to Switch Strategies

​See Also

Kelly Betting Strategies

Max Expected Value

Betting Strategies Concept

Benchmarking Guide

Build docs developers (and LLMs) love

Overview

When to Use

CategoricalMaxAccuracyBettingStrategy

Import

Usage

Parameters

How It Works

Real-World Examples

MaxAccuracyWithKellyScaledBetsStrategy

Import

Usage

Parameters

How It Works

Real-World Example

Berlin2OpenaiSearchAgentVariable

Strategy Comparison

Accuracy Metrics

Brier Score

Accuracy Rate

Calibration

Integration Patterns

Testing Then Optimizing

Confidence-Based Strategy Selection

Volume Strategy

Best Practices

Limitations

When to Switch Strategies

See Also