Automating Your Strategies with Predite's Bot Builder
Why Automate at All
Manual trading on Polymarket and Kalshi has a hard ceiling: you can only watch so many markets, and the best edges — a whale loading up on a contract, a fresh mispricing between two correlated markets, a news event that hasn't propagated into prices yet — tend to appear when you're asleep, in a meeting, or staring at a different market entirely. The Bot Builder exists to close that gap. It turns the strategies you already run by hand into rule-based agents that watch the order book around the clock, size positions consistently, and never get bored, greedy, or scared.
Automation is not a shortcut to skipping the thinking. A bot is only as good as the logic and the guardrails you give it. This guide walks through the eight templates, how to configure them safely, the execution model that runs them, and the discipline — paper-first, backtest-first, monitor-always — that separates traders who compound from traders who blow up. The Bot Builder is part of the Bot plan ($99/mo); the EV and analytics features it depends on live on Pro ($59) and Starter ($29), but live and paper bot execution is Bot-only.
The Eight Templates
Every bot starts from a template. A template is a pre-wired strategy skeleton — it defines what signal the bot looks for and how it translates that signal into an order. You then tune the parameters. Picking the right template is the single most important decision, because each one assumes a different kind of market inefficiency.
EV Follower
The workhorse. The EV Follower watches Predite's fair-value model and opens a position whenever the model's estimated probability diverges from the market price by more than your minimum edge. If the model says a contract is worth 0.62 and it's trading at 0.55, that's a 7-cent edge — buy. This template works best in liquid, frequently-repriced markets (major elections, Fed decisions, sports) where the model has enough data to be calibrated and where you can actually fill at the quoted price. It struggles in thin, idiosyncratic markets where the "edge" is really just model noise.
ARB Hunter
The ARB Hunter looks for a contract whose two sides don't add up. When YES and NO on the same market sum to less than 1.00 by at least your minimum spread — 8% by default — it buys both legs with matched share counts in the same cycle, a position that pays out at resolution whichever way the market goes. It sizes the legs for you and takes one arb per cycle. Two boundaries are worth knowing before you run it. It works *within* a single market, not across a basket of candidates: it never shorts and never assembles a multi-outcome basket. And cross-platform gaps between Polymarket and Kalshi reach you as an alert, not as a trade — Predite places real orders on Polymarket only, so the second leg would have nowhere to go. Its enemy is execution risk: the two legs are separate orders, so a partial fill leaves you directional instead of arbitraged. Keep the size small enough that one unmatched leg is survivable.
Whale Copier
This template subscribes to Predite's whale-tracking feed and mirrors the entry of wallets you've flagged — large, historically profitable accounts. When a tracked wallet takes a position above a size threshold, the bot opens a scaled-down version. Whale Copier shines when you've curated a short list of genuinely sharp wallets and want their conviction without watching the chain yourself. It fails when you copy indiscriminately: not every large wallet is smart money, and some are hedging positions you can't see. Use the whale's win-rate history to filter before you copy.
Mean Reversion
Mean Reversion fades a stretched price, but only with evidence. It compares the current price against the average of the last hour of price snapshots (excluding the most recent one), requires the gap to exceed your deviation threshold — 12 percentage points by default — requires a genuine volume spike in the latest interval (3x the median of the previous ones by default), and requires the AI to agree: minimum confidence, plus an estimate closer to the mean than to the stretched price. If the AI followed the price instead of the mean, the move may be justified and the bot does not fade. No price history for the market, no trade. Give it a max hold time as well, so a fade that never reverts gets closed instead of held forever.
News Reactor
The mirror image. News Reactor needs a real headline from the news feed as its catalyst: fresh (60 minutes old at most by default), non-neutral, in the category you chose, and matched to the market by overlapping terms. The direction comes from the AI, not from the sentiment score — a headline is rarely positive for both sides of a contract, and reading direction off sentiment is how a bot ends up buying the wrong outcome. No fresh matching headline means no trade, which is exactly what separates it from EV Follower. It works in markets that are demonstrably news-sensitive (geopolitics, crypto-adjacent contracts, company-specific Kalshi markets). The remaining risk is noise: headlines get revised, and with a 15-minute execution cadence (more on that below) you're not competing with millisecond bots — you're capturing the slower repricing that plays out over hours.
Calendar Bot
Calendar Bot is event-triggered rather than price-triggered. Its trigger is a real entry in the economic calendar: inside your lead time (24 hours by default, 2 to 48 allowed), at or above your minimum impact level, optionally narrowed by category, and matched to the market by overlapping terms. Direction and edge still come from the AI. What it does not do is learn a historical pre/post-event pattern — that dataset doesn't exist, and neither the bot nor this guide pretends otherwise. Use it where *timing* is the edge: positioning ahead of a print you already know is coming.
Rule Builder
The no-code escape hatch. Instead of a pre-wired thesis you stack your own entry conditions — minimum edge, price band, minimum volume, hours to resolution, whale entered above a given size, keyword, category — and all of them must hold for the bot to enter. Direction is still the AI's: a market that satisfies every condition but has no AI call is skipped rather than guessed. Exits come from the standard protection controls, so a Rule Builder bot inherits stop-loss, take-profit, trailing stop and max hold like any other. It has a dedicated guide of its own.
Fade Resolution
Plays the favourite-longshot bias in the final stretch before resolution, where cheap contracts tend to stay overpriced relative to how often they actually pay out. This is a small-edge, high-repetition template: it only works if you let it do the same thing many times, so run it in paper long enough to sit through a losing streak before you fund it.
Configuring Parameters
Templates give you the logic; parameters give you the risk profile. Six controls matter most, and they interact.
- •Minimum edge — the smallest divergence that triggers a trade. Set it too low (say 1 cent) and you'll fire constantly on noise and bleed to fees and slippage; set it too high (12+ cents) and you'll almost never trade. For an EV Follower on liquid markets, 4–6 cents is a sane starting band. ARB Hunter runs much tighter because the edge is near-certain.
- •Max size — the largest stake per position, in dollars or as a percent of bankroll. This is your blast radius. A common pattern is fractional Kelly: compute the Kelly-optimal size from your edge and odds, then take a quarter or half of it. Predite can surface the Kelly figure; resist the urge to bet full Kelly, which is mathematically aggressive and assumes your edge estimate is perfect.
- •Stop-loss — the adverse move at which the bot exits a losing position, set as a percentage of the entry price (30% if you leave it alone). Prediction markets are bounded (0 to 1), so a stop is less about ruin and more about freeing capital and admitting the thesis broke.
- •Take-profit — the favorable level at which the bot banks the win. Setting this matters because contracts can round-trip; locking in at 0.85 a position you entered at 0.55 realizes the gain rather than riding it back down.
- •Max loss — the accumulated loss at which the bot pauses itself and notifies you. This is the circuit breaker against a bad day compounding. Next to it sits a limit on frequency rather than money: max trades per day, counted from 00:00 UTC — once the bot hits it, it stops opening positions until the next day, and exits keep working. Useful for a strategy that fires on many small markets, where every money cap stays untouched while the position count climbs. On top of it the platform applies caps that no form can raise: $25 per order (up to $250 once your account is stepped up), $100 per day per bot, $500 per day across your whole account, and 3 open positions per bot. Configuring a bigger size does not lift them — the executor refuses the order.
- •Max hold and trailing stop — the two controls over time and path. A max hold closes the position after N hours, which is what finally kills a thesis that never played out; a trailing stop follows the price up and exits on a retrace from the peak. Note what bots do *not* have: a slippage-tolerance knob. Copy trading has one; a bot's protection against a bad fill is small size and the per-order cap.
A worked example. Suppose you run an EV Follower in paper with a $5,000 bankroll, min edge 5 cents, max size $150, stop-loss 30%, take-profit 50%, a 72-hour max hold and a max loss of $150. That's a deliberately conservative profile: small positions, a hard floor that pauses the bot, and an exit for theses that go nowhere. It will trade rarely and lose slowly even when wrong — which is exactly what you want while you're learning whether the edge is real. When the same bot goes live, remember the platform caps apply on top: the $150 you configured becomes $25 per order.
The 15-Minute Cron Execution Model
Predite bots do not run as a continuous high-frequency loop. They execute on a 15-minute cron cycle: every quarter hour, the platform wakes each active bot, pulls fresh market data and signals, evaluates the bot's rules, and places, adjusts, or closes orders accordingly. Between cycles, the bot is dormant.
This design is deliberate and has real consequences you should internalize:
- •You are not in a latency race. A 15-minute cadence means you will never beat a co-located market-making bot to a fleeting microsecond mispricing. That's fine — Predite's templates target inefficiencies that persist for minutes to hours (model divergences, whale entries, news repricing, calendar timing), not microstructure scalps.
- •Signals must survive the gap. An edge that exists at 10:00 and is gone by 10:07 won't be caught until 10:15, when it's stale. Strategies that depend on instantaneous reaction are the wrong fit. Strategies that exploit the *slow* propagation of information are the right fit.
- •Execution is checkpointed. Because evaluation is discrete, your stop-loss and take-profit are checked at each cycle, not tick-by-tick. A contract can spike past your stop and recover within one cycle and the bot may never act on it — or may act at the next cycle's price. Size your stops with that granularity in mind.
The cron model also makes the system predictable and auditable, which is what you want when real money is on the line. You always know when decisions happen, and every cycle is logged.
Paper-First Discipline
Never run a new bot live. Every bot in Predite can run in paper mode, where it executes against real market prices with simulated capital. Paper mode is not a toy; it's the proving ground. It runs the identical logic, the identical cron cycle, and records the identical metrics — it just doesn't touch your funds.
The discipline is simple to state and hard to follow: run every new configuration in paper for a meaningful sample before risking a cent. "Meaningful" means enough trades that the results aren't luck — as a rule of thumb, at least 30–50 closed positions, and ideally across different market conditions. A bot that looks brilliant over six trades has told you almost nothing. Watch specifically for the gap between *expected* and *realized* results: paper mode will reveal slippage and skip behavior that a backtest can hide.
Backtesting Before Live
Paper mode tests the future, forward, slowly. Backtesting tests the past, instantly. Before you even paper-trade, run the configuration against historical data to get a first read on whether the logic has ever made money. Predite has two backtests and the difference matters. The reverse backtest replays the real price history recorded for a market you choose and reports what the strategy would have done — it needs enough accumulated snapshots to say anything, and it covers a few core strategies rather than every template. The second engine is a synthetic Monte Carlo that explores the distribution of outcomes from assumptions you set; the app labels it as such, precisely so nobody reads a simulated equity curve as real performance.
Use backtesting to kill bad ideas cheaply and to tune parameters, but treat its results with suspicion:
- Overfitting is the enemy. If you tweak min edge, stop, and take-profit until the backtest looks perfect, you've likely fit the parameters to historical noise. They won't generalize. Prefer round, defensible numbers over hyper-optimized ones.
- The past underrepresents slippage. Backtests fill at historical quotes; live markets move against you. Always assume real performance is somewhat worse than the backtest.
- Regime changes break everything. A Mean Reversion bot that thrived in a quiet quarter can get shredded in a volatile one. A backtest spanning only calm conditions is misleading.
The healthy sequence is backtest → paper → small live → scale. Backtest to filter, paper to validate forward, go live small to confirm execution behaves, and only then increase size.
Monitoring What Matters
A live bot is not "set and forget." The Performance page breaks results down per bot and per copied wallet; four things deserve your regular attention.
- •Win rate — the share of closed positions that were profitable. Watch the *trend*, not just the level. A high win rate with tiny wins and rare huge losses can still be unprofitable; a 45% win rate with good payoff asymmetry can be excellent. Read it alongside P&L.
- •P&L, live and paper kept apart — the page never blends simulated money into real money, so a bot that only works on paper cannot hide inside a combined number. Compare the two: a wide gap between them is the cost of real execution.
- •Open positions — what the bot still has working right now. A bot holding positions far longer than you expected is usually missing a max hold or a take-profit, and it is also burning one of its three open-position slots.
- •Whether the bot paused itself — a bot that hit its max loss stops and notifies you. A paused bot is not a bug to restart; it is a result to read before you decide the strategy is still worth running.
Check these at least daily for a new live bot, and after any market regime shift (a big election resolving, a volatility spike) for established ones.
The Kill Switch
Every Predite bot has a kill switch — a single control that immediately halts all activity. Hitting it stops the bot from placing any new orders on the next cron cycle. This is your emergency brake for when something is clearly wrong: a market behaving bizarrely, a configuration you realize is broken, a news event that invalidates the whole strategy, or simply a string of losses that exceeds your comfort.
Two practices around it. First, know where it is before you need it — don't go hunting for the control while a bot is losing money. Second, lean on the automated daily max-loss limit as your always-on kill switch; the manual button is for the situations your rules didn't anticipate. The combination of a hard automated floor and a human override covers both the predictable and the surprising.
Combining Multiple Bots Without Overlap
Once one bot is working, the temptation is to run several. Diversification across uncorrelated strategies is genuinely powerful — but only if the bots don't step on each other. Overlap creates two hidden risks: concentration (three bots independently piling into the same contract, turning a 3% position into a 9% one) and self-competition (a Mean Reversion bot shorting the exact spike a News Reactor is buying, so you pay spread on both sides and net to nothing).
Manage it deliberately:
- Segment by market or theme. Give each bot a non-overlapping universe — one on politics, one on crypto, one on sports — so they can't collide on the same contract.
- Budget capital per bot. Allocate a fixed slice of bankroll to each so the total deployed is bounded even if every bot fires at once. Three bots at 3% max size each is a very different risk than three bots sharing one 9% pool.
- Avoid logically opposed templates on the same universe. Mean Reversion and News Reactor are natural antagonists; if you must run both, separate their markets or add a news filter so reversion stands down when a real event hits.
- Watch aggregate exposure. Monitor your *combined* position across all bots, not just each in isolation. The portfolio view is what tells you whether your "diversified" setup is secretly one big bet.
Done well, a stable of bots smooths your equity curve: when reversion is having a rough week, arb and calendar strategies carry it. Done carelessly, you've just built one fragile mega-position with extra steps.
Start Small, Then Compound
The Bot Builder rewards patience far more than cleverness. The traders who do well with it aren't the ones who deploy the most elaborate configuration on day one — they're the ones who backtest to filter ideas, paper-trade until the numbers are boringly consistent, go live with tiny size, read their skip reasons religiously, and only scale what has earned the trust. Pick one template that matches a market inefficiency you actually understand, give it conservative limits and a hard daily max-loss, and let it run in paper this week. When the metrics convince you — not before — turn on a small live allocation and watch your first real cron cycles execute. That first validated bot is the foundation everything else builds on, and the Bot plan is where it starts.