AdvancedAgent

Evidence-based prediction agent using web research and LLM analysis

Overview

The AdvancedAgent is a baseline agent that performs evidence-based predictions by searching Google, scraping web content, and analyzing it with an LLM. It represents the most basic approach to making informed predictions.

Class: AdvancedAgent

A trading agent that combines web search, content scraping, and LLM analysis to generate probabilistic predictions.

Inheritance

AdvancedAgent(DeployableTraderAgent)

Configuration Properties

bet_on_n_markets_per_run · int · default: "4"

Number of markets the agent will trade on per execution run

Methods

answer_binary_market

def answer_binary_market(self, market: AgentMarket) -> ProbabilisticAnswer | None

Generates a prediction for a binary market through a multi-step research process.

market · AgentMarket

The market to predict on

return · ProbabilisticAnswer | None

A probabilistic answer containing:

• p_yes: Probability of the “yes” outcome (0.0 to 1.0)
• confidence: Confidence in the prediction (0.0 to 1.0)
• reasoning: “I asked Google and LLM to do it!”

Returns None if no research results are found or content cannot be scraped.

Prediction Workflow

The agent follows a systematic research process:

1. Google Search

Searches Google for content related to the market question:

google_results = search_google_serper(market.question)

• Uses the Serper API for search results
• Filters out Manifold Markets results to avoid copying answers
• Returns None if no results are found

2. Web Scraping

Scrapes the top 5 search results:

contents = [
    scraped[:10000]
    for url in google_results[:5]
    if (scraped := web_scrape(url))
]

• Limits content to 10,000 characters per site
• Converts web pages to markdown format
• Returns None if no content can be extracted

3. LLM Analysis

Analyzes the scraped content using GPT-4o-mini:

probability, confidence = llm(market.question, contents)

• Uses GPT-4o-mini with temperature 0.0 for consistent predictions
• Provides current date context
• Returns probability and confidence as float values

Helper Function: llm

def llm(question: str, contents: list[str]) -> tuple[float, float]

Processes the research content and generates a prediction.

question · str

The market question to predict on

contents · list[str]

List of scraped web content (markdown format)

return · tuple[float, float]

A tuple containing:

• probability: Likelihood of the event occurring (0.0 to 1.0)
• confidence: Confidence in the prediction (0.0 to 1.0)

LLM Configuration

• Model: gpt-4o-mini
• System Prompt: “You are professional prediction market trading agent.”
• Temperature: 0.0 (deterministic)
• Output Format: “probability confidence” (space-separated floats)

Usage Examples

Basic Deployment

from prediction_market_agent.agents.advanced_agent.deploy import AdvancedAgent
from prediction_market_agent_tooling.markets.markets import MarketType

# Initialize the agent
agent = AdvancedAgent()

# Deploy locally
agent.deploy_local(
    market_type=MarketType.OMEN,
    sleep_time=300,  # 5 minutes between runs
)

Production Deployment

from prediction_market_agent.agents.advanced_agent.deploy import AdvancedAgent
from prediction_market_agent_tooling.markets.markets import MarketType
from prediction_market_agent.utils import APIKeys

# Ensure API keys are configured
api_keys = APIKeys()

# Initialize and deploy
agent = AdvancedAgent(
    enable_langfuse=True,  # Enable observability
    place_trades=True,
)

agent.deploy(
    market_type=MarketType.OMEN,
)

Custom Betting Strategy

from prediction_market_agent.agents.advanced_agent.deploy import AdvancedAgent
from prediction_market_agent_tooling.deploy.betting_strategy import (
    BettingStrategy,
    BinaryKellyBettingStrategy,
)
from prediction_market_agent_tooling.gtypes import USD

class MyAdvancedAgent(AdvancedAgent):
    def get_betting_strategy(self, market: AgentMarket) -> BettingStrategy:
        return BinaryKellyBettingStrategy(
            max_position_amount=USD(5),
            max_price_impact=0.7,
        )

agent = MyAdvancedAgent()
agent.deploy_local(market_type=MarketType.OMEN)

Required API Keys

The AdvancedAgent requires the following API keys (configured via environment variables):

SERPER_API_KEY · str · required

API key for Google search via Serper API

OPENAI_API_KEY · str · required

OpenAI API key for GPT-4o-mini model

Limitations

Content Filtering

• Filters out Manifold Markets results to avoid copying existing predictions
• You may want to filter other prediction market sites depending on your use case

Context Window

• Truncates each scraped page to 10,000 characters
• May miss important information at the end of long articles

Single LLM Call

• Makes only one LLM call for prediction
• No iterative refinement or multi-step reasoning

Error Handling

• Returns None if search fails
• Returns None if web scraping fails
• No fallback mechanisms

Performance Considerations

Baseline Agent

This agent serves as a baseline for comparison:

"""This is the most basic agent that should be actually able to do 
some evidence-based predictions. Use as a baseline for comparing 
with other agents."""

Speed vs. Quality

• Fast: Uses GPT-4o-mini (cheaper and faster)
• Simple: Single-pass prediction without refinement
• Basic: No advanced reasoning or multi-step analysis

Source Location

prediction_market_agent/agents/advanced_agent/deploy.py

Related

• Prophet Agent - Advanced agent using PredictionProphet library
• Think Thoroughly Agent - Multi-step reasoning agent
• DeployableTraderAgent - Base class for trading agents
• Web Scraping Tools - Content extraction utilities