This guy used Grok Bot to build a Two-Sided Accumulation bot on Polymarket Result: +$130,904 It trades 5 minute BTC Up/Down markets, combining complete-set accumulation with a directional residual Several Grok Bot AI agents work together as one algorithm: 1. Builds positions in Up and Down at different times It first accumulates one outcome, then starts buying the opposite side after the market moves Once it has matching shares on both sides, it merges them For example: 80 Up + 80 Down -> MERGE -> $80 If a pair’s total cost, including fees, is below $1, the difference becomes a structural edge 2. Keeps unpaired inventory directional If it buys: > 100 Up > 80 Down It can form 80 complete sets, while the remaining 20 Up shares stay directional Its Polymarket account: flippingsharks The system’s main edge comes from its inventory cycle: > Accumulates both sides > Builds complete sets for less than $1 > Keeps the unpaired remainder directional until resolution

This guy used Grok Bot to build an asynchronous complete-set trading system on Polymarket Result: +$319,430 The system makes 131 trades an hour in short-term crypto Up/Down markets, with an average trade size of $30.58 Several Grok Bot AI agents work together as one algorithm: 1. Builds positions on both sides It bought both Up and Down in 88.76% of markets The median gap between its first trades on each side is 35 seconds It then keeps switching between them as the market reprices, turning directional inventory into matched Up/Down pairs Average cost per pair: > Up + Down before fees = 96.35¢ > Up + Down after taker fees = 98.69¢ > Structural edge = 1.31¢ 2. Builds directional positions Only 58.66% of two-sided markets ended up with an average cost per pair below $1 after fees Some shares remain directional and provide an additional edge Its Polymarket account: norm1e69 The system’s main edge comes from asynchronous pairing: > It uses repricing to turn part of its Up and Down inventory into complete sets < $1 > It holds the unpaired remainder as a directional position until resolution

This guy used Grok Bot to build a directional repricing system on Polymarket Result: +$149,920 It trades 5 minute BTC, ETH, and SOL Up/Down markets using fair value estimates and dynamic hedging Several Grok Bot AI agents work together as one algorithm: 1. Looks for an undervalued outcome It uses data from external sources to continuously update P(Up) and P(Down) The model factors in the distance between the spot price and the opening level, time remaining, momentum, volatility, order flow, and a latency edge For example: > Down price = 67¢ > Model’s estimate for Down = 74% It enters a position when it identifies an edge After entry, the model keeps updating every few seconds. If confidence increases, the algorithm buys more of the same outcome 2. Hedges when the signal changes If the edge starts to disappear, it may sell part of its original position If the signal completely reverses, it sometimes buys the opposite outcome Its Polymarket account: trinity42 The algorithm’s main edge comes from the gap between its own fair value estimate and the current market price: > Buys undervalued outcomes quickly > Increases position size as confidence grows > Reduces exposure when the original signal starts to change

This guy used Grok Bot to build a Quant Signature Map system and made $431,498 on Polymarket His system trades BTC Up/Down markets with an average trade size of $22.31 and 109 trades per active hour, averaging $3,038 a day Several AI agents work together as one algorithm: 1. Path Signature captures the sequence of BTC price and volume changes The first agent calculates a numerical measure from BTC trades on external markets: A = ½ × (∫ X dV - ∫ V dX) Both series are measured from the start of the market. This measure captures information about the order in which price and volume change 2. Calibration Map translates the movement pattern into Up and Down values The second agent combines the signature, distance from the reference price, volatility, and time remaining into a Score: pUp = 1 / (1 + e^(-Score)) pDown = 1 - pUp Entry condition: Up Entry Price + Costs < pUp × $1 When the condition is met, the system places an order. As external order flow changes, it updates its valuation and position parameters This trader’s Polymarket account: bosona If you want to trade BTC/ETH price movements directly, you can use KCEX: kcex.com/register?inviteCode… This exchange currently offers 0% fees on some spot/perp pairs, as well as 0% fees on the first 100 withdrawals each month across all assets At $1M in trading volume, even a 0.1% fee adds up to $1,000 in costs. That’s why zero fees can help preserve more of a trading strategy’s edge

This guy used Grok Bot to build a Quant Flow Memory system and it made $1,700 a day on Polymarket The result is already +$357,000 PnL over 210 days. It makes 48.8 trades per active hour across BTC Up/Down markets Several AI agents work together as one algorithm: 1. Multilevel Flow tracks order changes across several order book levels The first agent records new orders, cancellations, and fills separately for Up and Down For each side, it calculates: Flowₜ = Σ wₖ × OFIₖ,ₜ Where: > OFIₖ,ₜ = order flow imbalance at level k > wₖ = the weight assigned to that level The calculation tracks changes in buy and sell queues This helps the system distinguish a single change at the best price from a consistent shift in liquidity across multiple levels 2. Flow Memory connects past order flow with subsequent repricing The second agent combines several recent readings: Responseₕ = Σ gⱼ × Flowₜ₋ⱼ Where: > gⱼ = the learned weight assigned to a flow reading from j intervals earlier > h = the selected holding period The weights are calibrated using historical data: each flow pattern is matched with the change in the midpoint of the spread h seconds later For example: > Calculated price move = 3¢ > Entry and exit costs = 1¢ > Edge = 2¢ per share It keeps BUY limit orders in place while the calculated price response still leaves an edge after costs The position is closed at an executable sell price when the chosen price level or time limit is reached This trader’s Polymarket account: BoneOhio You can build your own trading bot here: join.horizon.trade/retrovali… (A trial is available after signing up) Top trades: $225.32 → $1,709.44 (+$1,484.12) $2,237.72 → $3,562.38 (+$1,324.66) $995.78 → $2,306.53 (+$1,310.75) The system looks for an edge in subsequent repricing: Multilevel Flow measures order flow across price levels, while Flow Memory identifies the price response associated with that sequence

This guy used Grok Bot to build a Quant Queue Markout system, and it made $2,749 a day on Polymarket The result is already +$412,336 PnL over 150 days, with an average trade size of $33.50 and 150 trades per active hour across BTC Up/Down markets Several AI agents work together as one algorithm: 1. Queue-Reactive uses order queue conditions to choose where to place limit orders The first agent tracks volume at each price level, new orders, cancellations, and fills For each level: Q_next = Q_now + Added - Cancelled - Executed The system calibrates these event rates separately for different order book conditions It then selects a BUY limit price based on the estimated volume ahead of the order and how quickly the queue moves Orders placed at the same price can fill differently depending on the structure of the order book 2. Markout measures the price difference after a fill The second agent compares the entry price with the midpoint of the spread after a set interval: Markout = Midₜ₊Δ − Fill Price For example: > Fill = 48¢ > Midpoint after 2 seconds = 51¢ > Markout = 3¢ per share These readings are tracked separately for each queue state The results guide where the next limit orders are placed and how long positions are held Actual exit calculations use the available sell price and account for execution costs His Polymarket account: almach Best trades: $859.80 → $2,999.80 (+$2,140.00) $617.72 → $2,565.80 (+$1,948.08) $1,344.20 → $3,130.50 (+$1,786.30) The system looks for an edge in execution: Queue-Reactive guides order placement, while Markout measures the price difference that remains after each purchase

This guy used Grok Bot to build a Quant Hawkes Response system and it made $1,294 a day on Polymarket The result is already +$129,437 PnL in 100 days, with an average trade size of $26.56 and about 54 trades per active hour across BTC Up/Down markets Several AI agents work together as one algorithm: 1. Hawkes Process calculates an activity reading from the timing of BTC trades The first agent tracks BTC buys and sells executed immediately at available quotes on an external market Each new trade contributes to the activity reading, with its weight determined by the time elapsed For one stream, the calculation is: λ(t) = μ + Σ α × e^(−β × (t − tᵢ)) Where: μ - baseline event rate α - initial contribution of each new trade β - parameter controlling how that contribution is weighted over time More recent events receive greater weight in the calculation 2. Price Response converts the activity reading into calculated Up and Down values BTC’s price response depends on both trade flow and order book depth The second agent combines the activity reading with historical price-response data and liquidity replenishment It calculates Up and Down values for the remaining market interval using the market’s closing criteria For example: 6,200 of 10,000 numerical runs meet the Up criteria > Calculated Up Value = (6,200 / 10,000) × $1 = 62¢ > Total entry cost = 58¢ per Up share > Edge = 62¢ - 58¢ = 4¢ per share This trader’s Polymarket account: NIULAI4 Best trades: $3,136.84 → $8,117.78 (+$4,980.94) $4,296.61 → $8,530.04 (+$4,233.43) $1,007.34 → $4,121.59 (+$3,114.25) Hawkes turns trade timing into an activity reading, while Price Response compares calculated Up and Down values with their total entry costs

This guy used Grok Bot to build a directional trading bot on Polymarket with an average trade size of $23.59 Result: +$265,376 This algorithm trades short-term crypto Up/Down markets by estimating fair probabilities, dynamically hedging its positions, and pairing part of its inventory: 1. Buys an outcome when its model identifies an edge It continuously updates its estimates for Up and Down and compares them with Polymarket prices If an outcome looks undervalued, it starts buying that side 2. Switches to the opposite outcome when the signal changes It can switch several times within one market: Up -> Down -> Up As a result, part of its original position becomes hedged It bought both sides in about 90% of markets 3. Builds complete sets with part of its inventory and keeps the rest directional In two-sided markets, the median combined cost was: VWAP(Up) + VWAP(Down) = 94.5c The combined VWAP was below $1 in about 62.5% of those markets But this is not pure arbitrage The median position imbalance is about 40% of the total share count, leaving part of its inventory directional This trader’s Polymarket account: pspspsps5 The algorithm’s main edge comes from continuously updating its directional view. It first buys the outcome its model considers undervalued, uses the opposite side as a dynamic hedge, and turns part of the resulting inventory into complete sets < $1

This guy used Grok Bot to build an HFT algorithm on Polymarket Result: +$617,464 over 128 days This algorithm trades 5 minute BTC and ETH Up/Down markets using asynchronous complete-set accumulation, inventory management, and a directional residual Several AI agents work together as one system: 1. Buys both outcomes The median gap between its first trades on each side is 7.5 seconds 2. Uses repricing to lower the combined cost As BTC or ETH moves, it keeps buying Up and Down at different prices to bring their combined average cost below $1: VWAP(Up) + VWAP(Down) < $1 The average combined cost of its matched pairs is 97.93c -> Edge 2.07c 3. Keeps a directional residual The median ratio of the larger position to the smaller one is about 1.44 : 1 The excess shares form a directional position in the outcome its fair value model considers more likely This trader’s Polymarket account: x-MoneyForWhiskas Most profitable trades: $1,038 -> $3,496 (+236.8%) $1,578 -> $4,811 (+204.9%) $1,664 -> $4,233 (+154.5%) The algorithm’s edge has two layers: it builds complete sets for less than $1 per pair and keeps a directional residual alongside them

This guy used Grok Bot to build a two-sided market-making system on Polymarket Result: +$179,327 The system trades BTC Up/Down markets with an average trade size of $52.78 and 112.5 trades per active hour It places limit orders for both outcomes, builds complete sets for less than $1, and manages the remaining directional exposure Six AI agents work together as one system: > SCAN: Tracks prices on both sides, the spread, liquidity, and time until the market closes > QUOTE: Sets bid prices and order sizes for Up and Down, updating them as the market moves and inventory changes > PAIR: Calculates the combined cost of each Up/Down pair and identifies complete sets below $1 > BALANCE: Manages directional exposure from unpaired shares > EXEC: Places, cancels, and replaces orders. Tracks fills and shares updated position data with the other agents > AUDIT: Reviews results, measures how much edge remains after rebalancing, and identifies opportunities to improve efficiency Each agent has ongoing responsibilities and its own working context Handoffs connect the stages Skills store the workflow rules Routines run checks and generate reports This trader’s Polymarket account: Polkadot-Frog The edge of this six-agent system depends on the combined cost of both outcomes and execution quality. Rebalancing reduces the remaining directional exposure