Flore is an ultra-low latency trading tool operating on parallel markets such as Polymarket. I used C++ to meet the performance and latency demands, and it's currently running on AWS bare-metal instances. I use two algorithmic processes to trigger orders, with sub-20 µs reaction time. This project is in constant progress and improvement; the latest live metrics are at the bottom of this page.
The Challenges
To build this, I've been consistently solving new challenges along the way. Here's the full story from start to current.
What brought my attention to Polymarket is when I started building a tracking tool on it: polytracker.io
When I went on the BTC 15-minute market, I noticed something strange that caught my attention:
The price of the shares were moving before the BTC price on the graph... Did they know the price of Bitcoin before me? Short answer: Yes.
Scratch
So after some serious grinding, I finally found different live feeds that gave me a clear edge over the streams that other arbitrage bots and Polymarket were using. With that, I started building the main algorithm:
V1.0
Machine Learning
The algorithm was a tough build. The stream was really raw and inconsistent, full of spikes and random noise. I had to clean everything out myself.
The algorithm was okay, but I wanted something that could evolve with time. Thankfully, I had some machine learning experience. That's when I started recording hundreds of markets, built my own dataset, and trained my own MLP.
So I went back to my dataset and ran a bunch of data visualizations to understand what was happening, and that's when it clicked!
I fixed my dataset, trained it again, and it worked! Here are the backtesting results that confirmed it:
Here is a live presentation of my MLP running on 105 unseen markets, around 25 hours of recorded data.
I'll spare you the other challenges along the way: building our own liquidity with a two-agent system to sell positions instantly, achieving data processing in under 500µs, landing transactions before every other arbitrage bot, pre-calculating market depth to adjust bet sizing, implementing a retry evaluation system, implementing variable slippage, pre-calculating fees, renting dedicated servers across different countries to avoid getting banned by Polymarket, and more...
V2.0
Renaissance
Unfortunately, despite all that work, two big problems were still standing in the way.
1. My backtests were not faithful to reality. Polymarket's latency is an unknown variable, and nobody has a way to model it. Every latency model I built fell apart: from one moment to the next, an order would go from 150 ms to 450 ms, and in those 300 ms the price could double while the market makers pulled their orders.
2. Polymarket itself was my biggest problem. Beyond latency, every two weeks a new trading rule came in, changes that completely reshuffled the way market makers priced the shares. Each time, that meant recording the markets all over again and retraining a model that had never even seen production.
- Feb 2026The 500 ms taker delay on crypto markets disappears overnight, with no announcement.
- Spring 2026A taker delay comes back: every taker order now waits ~250–300 ms before it can execute.
- 7 Aug 20265-minute markets switch to resolving on a 30-second Chainlink TWAP.
- 17 Aug 2026Taker delay cut from 250 ms to 50 ms at 11:00 UTC.
- LaterThe resolution window widens again to a 60-second TWAP.
Because of that, I took a few weeks off to think, and went back to my YouTube community, where I teach people how to develop in C++. Then one evening I decided to start again, this time integrating AI far deeper into the way I create algorithms.
And that's when it clicked.
Between July 24 and September 8, I ran 9 algorithms live:
And that's where I'm at now: