The Polymarket Edge the Crowd Does Not Have
You have been watching prediction markets. The prices look efficient. Every major news event is priced within minutes. You write a thesis, the market has already moved. You spot a trend, someone else spotted it first. If everyone is reading the same news, the market is nearly impossible to beat on information you can all access at the same time.
The crowd on Polymarket is fast at processing news. It is slow at processing causes.
What the Market Is Actually Pricing
Prediction markets price publicly available information reacted to by the people who are paying attention. The people paying attention are mostly reading news, watching social media, tracking official sources. They are excellent at updating on facts. They are poor at tracing the causal structure behind those facts.
When a central bank signals a policy shift, the market prices the policy. It does not reliably price the downstream effects on adjacent sectors, the upstream conditions that forced the decision, or the historical patterns in similar regimes that predict what comes next.
When a company announces a leadership change, the market prices the announcement. It does not price the six months of board meetings, investor pressure, and competitive signals that preceded it, or the pattern of similar leadership changes in comparable companies and what followed them.
The gap between what happened and what caused it to happen is where systematic edge lives. That gap is not accessible from reading the same news feed as everyone else.
So ask yourself: if you were going to find a real edge in prediction markets, where would it come from? Not faster news. Not better intuition about which way public sentiment breaks. Something structural. Something the crowd consistently misprices because they do not have the apparatus to see it.
What Causal Graph Intelligence Actually Is
A knowledge graph that tracks causal relationships between entities can surface patterns the crowd cannot see because the crowd does not have a graph.
The graph knows that Entity A has a 0.78 causal weight to Entity B, based on historical propagation patterns. It knows that when Entity A enters a pre-tipping regime, Entity B typically follows within a defined time window. It knows which investors backed both companies in a contested sector, which regulatory decisions consistently precede market moves, which leadership patterns correlate with acquisition targets.
When a market on Polymarket asks whether Event B will occur, the crowd is pricing it based on what they know about B directly. A system with a causal graph can price it based on the state of A, the historical causal weight from A to B, the current regime of A, and the strength of the signal propagation chain.
If the crowd has priced B at 35% and the graph-implied probability based on causal upstream state is 58%, that is a 23-point edge. That is not a certainty. It is an expected value proposition. At sufficient volume, those edges compound.
How the Bot Finds the Mispricings
The architecture is five stages.
Stage 1: Market scanning
The bot connects to Polymarket's CLOB API and scans all active markets. It filters for minimum liquidity (default $500), maximum days to expiry (default 90), and markets where the question entity maps to something in the knowledge graph.
Stage 2: Entity mapping
For each market question, the bot extracts keywords and queries the graph for matching entities. "Will Tesla announce layoffs in Q2?" maps to the Tesla entity. "Will the Fed raise rates at the June meeting?" maps to Federal Reserve and the interest rate regime chain.
Stage 3: Causal context retrieval
# Get upstream causal parents of the market entity graph.get_causal_parents(entity_id) # Returns: entities that causally precede this one # with historical weight and time-lag data # Get current regime of upstream entities graph.get_regime(upstream_entity_id) # Returns: stable | pre_tipping | tipping | post_tipping # Get active signals on the causal chain graph.get_signals(entity_id, lookback_days=30) # Returns: signal strength, direction, recency
Stage 4: Edge calculation
The graph-implied probability is derived from the upstream entity state, the causal weight from that entity to the market entity, and the current signal direction. The edge is the difference between the graph-implied probability and the current Polymarket price.
graph_prob = base_rate * causal_weight_modifier * regime_modifier * signal_modifier edge = graph_prob - market_price # Positive edge = market underpricing YES # Negative edge = market underpricing NO kelly_fraction = edge / (1 - market_price) * kelly_multiplier position_size = min(bankroll * kelly_fraction, max_position_usdc)
Stage 5: Execution with risk controls
The bot only trades when edge exceeds a minimum threshold (default 8%), confidence is above the minimum causal weight (default 0.55), and the position does not breach daily loss limits or maximum concurrent position count. DRY_RUN mode logs all signals without placing orders, so you can verify the system is finding real edge before committing capital.
The HIP-4 Arb Layer
Beyond causal mispricings, the bot includes a second strategy: cross-exchange arbitrage between Polymarket and Hyperliquid's HIP-4 prediction market protocol.
When the same outcome trades on both exchanges with a spread above 3%, the bot identifies the cheaper side, calculates the net edge after fees, and executes both legs. Both prices will converge to 0 or 1 at resolution. The spread is captured regardless of the outcome.
This strategy requires no causal intelligence. It requires only that both markets exist simultaneously, that the spread is real, and that the execution is fast enough to capture it before others close it.
What You Need to Run It
The bot is open-source and deployable in DRY_RUN mode without any capital.
To start scanning markets and logging signals:
DRY_RUN=true \ GRAPH_SECRET=your_forage_graph_token \ py -m polymarket.bot
The bot will connect to Polymarket's CLOB, scan active markets, map them to the knowledge graph, calculate edge on every mapped market, and log every signal above threshold. You watch the signals for a cycle or two before switching DRY_RUN to false.
To place live trades:
DRY_RUN=false \ POLYGON_PRIVATE_KEY=your_polygon_wallet_key \ GRAPH_SECRET=your_forage_graph_token \ INITIAL_BANKROLL_USDC=1000 \ py -m polymarket.bot
Your wallet needs USDC on Polygon. Polymarket runs on Polygon mainnet. Position sizes are Kelly-fractioned by default at 0.25 of full Kelly, with a maximum position size of 5% of bankroll per trade.
The Edge Is in the Graph, Not the News
There is no alpha in being a fast reader of the same information as the crowd. There is potential alpha in having a structured causal model of how events relate to each other that the crowd cannot replicate because they are not running a graph.
The knowledge graph that feeds this bot is the same one that powers Forage's B2B intelligence tools. Every research session, every signal logged, every causal relationship verified adds to the graph. The bot benefits from every prior session that touched the same entities.
No subscription. Pay-per-call at £0.0025 per graph query. At the query volumes a 30-minute scan cycle requires, the intelligence cost per cycle is under £1.
If you are going to trade prediction markets, the question is whether you are trading on the same information as everyone else or on a causal model nobody else is running. Visit useforage.xyz to access the graph.