MiroFish for Trading: Deep Dive

March 22, 2026

MiroFish for Trading: Deep Dive

Research Date: 2026-03-17

Requested by: Jack

1. Polymarket Application

What Already Exists: PrediHermes

Someone has already built a full pipeline connecting MiroFish to Polymarket. The project is called PrediHermes (github.com/nativ3ai/hermes-geopolitical-market-sim), published March 16, 2026.

Architecture:

WorldOSINT (OSINT signals) → PrediHermes pipeline → Polymarket market selection → MiroFish simulation → Summary/decision

What it does:

  • Pulls OSINT data (news, RSS, topic-specific signals) via WorldOSINT headless modules
  • Queries Polymarket Gamma/CLOB API for open markets with live yes/no bid/ask data
  • Feeds that data as seed material into MiroFish for multi-agent simulation
  • Supports counterfactual injection (inject new actors/events mid-simulation to see how outcomes shift)
  • Outputs: directional call, implied vs. forecast comparison, reasoning
  • Can be scheduled via cron for daily automated runs

Key technical details:

  • Built as a "Hermes skill" (Hermes is an AI agent framework)
  • Uses OpenAI Codex / GPT-5.3-codex-medium as the LLM backend
  • Supports macOS launchd for persistent background operation
  • Has a CLI (predihermes) and chat interface

Example workflow:

  1. Track a topic: predihermes track-topic --topic-id iran-conflict --topic "Iran conflict" --market-query "Iran nuclear deal"
  2. Run with simulation: predihermes run-tracked iran-conflict --simulate
  3. Dashboard: predihermes dashboard iran-conflict (shows drift signals, implied vs. forecast)

Counterfactual branching -- this is the most interesting part for trading. You can fork a simulation, inject a new variable (e.g., "Swiss envoy proposes verification-first diplomacy"), and compare the branched outcome against the base case. This lets you model "what if X happens" scenarios against live market pricing.

X/Twitter Thread (March 16, @0x_Discover)

Another developer independently built a MiroFish-inspired system for Polymarket:

  • Simulates agents as: voters, media, donors, traders, pollsters
  • Agents update beliefs → clusters form → sentiment shifts emerge
  • Claims "insane" results vs. simple probability models
  • Key insight: "Prediction markets move on behavior, not just math"

Bottom line on Polymarket: This is currently the best-fit use case for MiroFish. Binary outcome markets with clear event catalysts are ideal for behavioral simulation. The tooling already exists. The question is whether the simulation accuracy justifies the LLM compute cost.

2. Cost-Benefit Analysis

Costs

LLM API costs (the dominant expense):

  • Each agent interaction = 1+ LLM API call
  • A simulation with 1,000 agents running 20 rounds = ~20,000 API calls minimum
  • At scale (700K agents), compute is massive -- but you don't need 700K for trading applications
  • Realistic trading config: 200-500 agents, 15-30 rounds

Estimated per-simulation costs (using OpenAI API pricing as baseline):

ConfigAgentsRoundsEst. API CallsEst. Cost (GPT-4o)Est. Cost (GPT-4o-mini)
Minimal5010~500~$1-2~$0.10-0.20
Light20020~4,000~$8-15~$0.80-1.50
Medium50030~15,000~$30-50~$3-5
Heavy2,00040~80,000~$150-250~$15-25

Note: These are rough estimates. Actual costs depend on prompt length, agent memory size, and model choice. The project recommends Alibaba's Qwen (qwen-plus) which is significantly cheaper than OpenAI.

Using Qwen-plus via Alibaba Bailian:

  • Roughly 5-10x cheaper than GPT-4o
  • A "Light" simulation might cost 1−2insteadof1-2 instead of 8-15
  • This is what the MiroFish team recommends

Other costs:

  • Zep Cloud (agent memory): Free tier sufficient for small experiments
  • Compute: Runs on CPU for small simulations; larger ones benefit from GPU
  • Infrastructure: Docker or bare metal; a decent VPS ($20-50/mo) would work for light use

If you ran 3-5 simulations per day for options trading (light config, Qwen):

  • Daily cost: ~$5-10 in API calls
  • Monthly: ~$150-300

Benefits (Theoretical)

  • Behavioral edge: Models HOW crowds react, not just statistical patterns
  • Scenario testing: Run "what if Fed holds" vs. "what if Fed cuts" and compare sentiment distributions
  • Pre-event positioning: Run simulation before earnings, FOMC, CPI releases
  • Non-obvious reactions: The swarm might surface second-order effects (e.g., "rate hold causes panic because market expected cut, not relief")

Risks

  • No backtesting exists. Zero verified track record against real market outcomes
  • LLM hallucination risk. Agents are powered by language models -- they can generate plausible-sounding but wrong behavioral patterns
  • Latency. A simulation takes minutes to hours. Not suitable for intraday scalping
  • The map is not the territory. Agent personalities come from LLM training data, not real market participants

3. Options Daytrading on IBKR -- Feasibility Assessment

The Hard Truth

MiroFish is not designed for daytrading. Here's why:

  1. Speed mismatch. Even a minimal simulation takes several minutes. Options daytrading requires sub-second to minute-level decision-making
  2. Signal type mismatch. MiroFish outputs behavioral probability distributions ("crowd will likely panic"). Options daytrading needs specific: direction, magnitude, timing, and strike/expiry selection
  3. No price-level output. MiroFish does not output price targets. It outputs sentiment patterns. You'd need an entire additional layer to translate "crowd sentiment shifts bearish" into "buy SPY 520P 0DTE"

What COULD Work: A Hybrid Architecture

If you're determined to use MiroFish for IBKR options trading, the viable approach is as a pre-market sentiment engine, not a real-time trading bot.

Proposed architecture:

[Pre-Market Phase: T-60min to Open]
  News/Event scraping → MiroFish simulation (light, 15min run)
  Output: Sentiment bias + confidence level for key catalysts
      ↓
[Signal Translation Layer]
  MiroFish sentiment → directional bias (bullish/bearish/neutral)
  + magnitude estimate (strong/moderate/weak)
  + key risk scenarios identified
      ↓
[IBKR Execution Layer]
  ib_insync (Python library for IBKR API)
  Takes: direction + magnitude + risk parameters
  Outputs: specific options orders (strike, expiry, size, stops)
      ↓
[Risk Management Layer]
  Position sizing, max loss limits, Greeks management
  Auto-close at stop loss or profit target

The execution layer (IBKR side) is well-established:

  • ib_insync -- the standard Python library for IBKR TWS/Gateway API
  • Supports: market data, order placement, options chains, portfolio management
  • Can programmatically: scan options chains, calculate Greeks, place/modify/cancel orders
  • Requires TWS or IB Gateway running locally

What you'd need to build:

  1. News/event scraper -- Pull pre-market catalysts (earnings, economic data, geopolitical events)
  2. MiroFish adapter -- Format scraped data as MiroFish seed material, run simulation, parse output
  3. Signal translator -- Convert MiroFish sentiment output into actionable options parameters
  4. IBKR bot -- ib_insync-based execution engine with risk management
  5. Feedback loop -- Track P&L against MiroFish predictions to calibrate over time

A More Realistic Use Case: Event-Driven Options Plays

Instead of daytrading, MiroFish is better suited for event-driven options strategies:

Event TypeMiroFish RoleOptions Strategy
FOMC decisionSimulate crowd reaction to each possible outcomeStraddles/strangles pre-event, directional post-event
Earnings releaseSimulate market participant reaction to beat/miss scenariosPre-earnings positioning based on sentiment skew
CPI/jobs dataSimulate how different readings cascade through market sentimentDirectional plays based on "surprise" behavioral modeling
Geopolitical shockSimulate contagion and panic dynamicsVIX calls, sector rotation plays

Workflow for event-driven trading:

  1. Day before event: Run 2-3 MiroFish simulations (base case, bull case, bear case)
  2. Compare simulation sentiment distributions
  3. If one scenario shows strongly asymmetric crowd reaction → position accordingly
  4. Use options to express the view with defined risk (spreads, not naked positions)

IBKR Technical Integration

Requirements:

  • IBKR Pro account (not Lite -- need API access)
  • TWS or IB Gateway installed and running
  • Python with ib_insync: pip install ib_insync
  • Options trading permissions enabled on account
  • Market data subscriptions for relevant underlyings

Basic connection:

from ib_insync import *

ib = IB()
ib.connect('127.0.0.1', 7497, clientId=1)  # TWS paper trading port

# Get SPY options chain
spy = Stock('SPY', 'SMART', 'USD')
ib.qualifyContracts(spy)
chains = ib.reqSecDefOptParams(spy.symbol, '', spy.secType, spy.conId)

The gap you'd need to bridge: There is no existing MiroFish → IBKR connector. You'd be building custom integration. Estimated development effort: 2-4 weeks for a basic prototype, assuming Python proficiency.

4. Recommendations

If you want to experiment (low risk):

  1. Deploy MiroFish locally (Docker, ~30min setup)
  2. Use Qwen-plus as the LLM backend (cheapest option)
  3. Run simulations on upcoming known events (next FOMC, earnings for stocks you follow)
  4. Compare MiroFish output against what actually happens
  5. Do this for 2-4 weeks before putting any money on it
  6. Cost: ~$50-100 for a month of experimentation

If the experiments look promising:

  1. Build the signal translation layer (MiroFish sentiment → directional bias)
  2. Paper trade on IBKR using the signals for 1-2 months
  3. Track win rate, average P&L per trade, max drawdown
  4. Only go live with real money after verified edge in paper trading

What I would NOT do:

  • Do not automate live options trading based on MiroFish signals without extensive paper trading validation
  • Do not use MiroFish for intraday scalping -- the latency and signal type are wrong
  • Do not run large-scale simulations (500+ agents) until you've validated the approach with smaller, cheaper runs
  • Do not treat MiroFish output as a trading signal -- treat it as one input to a thesis

The Polymarket angle may be the better play:

  • Binary outcomes are simpler to model than options payoffs
  • PrediHermes already exists as tooling
  • Lower stakes for experimentation
  • Faster feedback loop (event resolves, you know if you were right)

Sources

  • MiroFish GitHub: github.com/666ghj/MiroFish
  • PrediHermes: github.com/nativ3ai/hermes-geopolitical-market-sim
  • Moneycontrol coverage: moneycontrol.com (March 13, 2026)
  • Dev.to technical writeup (March 16, 2026)
  • abhs.in analysis (March 14, 2026)
  • @0x_Discover Polymarket thread (March 16, 2026)