Research Agents

python prediction_market_agent/run_agent.py advanced_agent omen

class AdvancedAgent(DeployableTraderAgent):
    bet_on_n_markets_per_run = 4

    def answer_binary_market(self, market: AgentMarket) -> ProbabilisticAnswer | None:
        # Search for results on Google
        google_results = search_google_serper(market.question)
        
        # Filter out Manifold results
        google_results = [url for url in google_results if "manifold" not in url]
        
        if not google_results:
            return None
        
        # Scrape and truncate content
        contents = [
            scraped[:10000]
            for url in google_results[:5]
            if (scraped := web_scrape(url))
        ]
        
        if not contents:
            return None
        
        # Get LLM prediction
        probability, confidence = llm(market.question, contents)
        
        return ProbabilisticAnswer(
            confidence=confidence,
            p_yes=Probability(probability),
            reasoning="I asked Google and LLM to do it!",
        )

def llm(question: str, contents: list[str]) -> tuple[float, float]:
    agent = Agent(
        OpenAIModel("gpt-4o-mini", provider=get_openai_provider()),
        system_prompt="You are professional prediction market trading agent.",
    )
    result = agent.run_sync(
        f"""Today is {utcnow()}.
        
        Given the following question and content from google search, 
        what's the probability that the thing in the question will happen?
        
        Question: {question}
        
        Content: {contents}
        
        Return only the probability float number and confidence float number, 
        separated by space, nothing else."""
    ).output
    probability, confidence = map(float, result.split())
    return probability, confidence

python prediction_market_agent/run_agent.py think_thoroughly omen

class DeployableThinkThoroughlyAgent(DeployableThinkThoroughlyAgentBase):
    agent_class = ThinkThoroughlyWithItsOwnResearch
    bet_on_n_markets_per_run = 1

    def get_betting_strategy(self, market: AgentMarket) -> BettingStrategy:
        return FullBinaryKellyBettingStrategy(
            max_position_amount=get_maximum_possible_bet_amount(
                min_=USD(1),
                max_=USD(5),
                trading_balance=market.get_trade_balance(APIKeys()),
            ),
            max_price_impact=None,
        )
    
    def before_process_markets(self, market_type: MarketType) -> None:
        # Ensure all markets are indexed in Pinecone
        self.agent.pinecone_handler.insert_all_omen_markets_if_not_exists()

python prediction_market_agent/run_agent.py think_thoroughly_prophet omen

class DeployableThinkThoroughlyProphetResearchAgent(DeployableThinkThoroughlyAgentBase):
    agent_class = ThinkThoroughlyWithPredictionProphetResearch
    bet_on_n_markets_per_run = 1
    
    # Uses tiny bets - not yet optimized for profitability

# Prediction Prophet provides:
- Subquery generation (breaks question into searchable parts)
- Multi-source web scraping
- News relevance filtering
- Source credibility assessment
- Evidence aggregation

python prediction_market_agent/run_agent.py gptr_agent omen

class GPTRAgent(DeployableTraderAgent):
    bet_on_n_markets_per_run = 4

    def get_betting_strategy(self, market: AgentMarket) -> BettingStrategy:
        return FullBinaryKellyBettingStrategy(
            max_position_amount=get_maximum_possible_bet_amount(
                min_=USD(0.1),
                max_=USD(8),
                trading_balance=market.get_trade_balance(APIKeys()),
            ),
            max_price_impact=0.57,
        )

    def answer_binary_market(self, market: AgentMarket) -> ProbabilisticAnswer | None:
        # Generate research report
        report = gptr_research_sync(market.question)
        
        # Make prediction based on report
        prediction = prophet_make_prediction(
            market_question=market.question,
            additional_information=report,
            agent=Agent(OpenAIModel("gpt-4o")),
            include_reasoning=True,
        )
        return prediction

def gptr_research_sync(query: str) -> str:
    researcher = GPTResearcher(query=query, report_type="research_report")
    asyncio.run(researcher.conduct_research())
    report: str = asyncio.run(researcher.write_report())
    return report

python prediction_market_agent/run_agent.py gptr_agent_highest_liquidity omen

class GPTRHighestLiquidityAgent(GPTRAgent):
    get_markets_sort_by = SortBy.HIGHEST_LIQUIDITY
    bet_on_n_markets_per_run = 2
    same_market_trade_interval = FixedInterval(timedelta(days=7))

# Required
OPENAI_API_KEY=sk-...

# For Advanced Agent
SERPER_API_KEY=...

# For Think Thoroughly / GPTR
TAVILY_API_KEY=...
PINECONE_API_KEY=...

# Reduce research costs
DeployablePredictionProphetAgent(
    subqueries_limit=3,  # Fewer searches
    min_scraped_sites=3,  # Fewer sites to scrape
)

# Or use cheaper models
AdvancedAgent()  # Uses gpt-4o-mini

# Think Thoroughly for high-value markets
agent = DeployableThinkThoroughlyAgent(
    enable_langfuse=True,
    bet_on_n_markets_per_run=1,
    place_trades=True,
)

# GPTR for balanced approach
agent = GPTRAgent(
    bet_on_n_markets_per_run=4,
    enable_langfuse=True,
)