A market maker for Kalshi's liquidity rewards
A market-making bot for Kalshi's liquidity rewards. It picks markets by expected reward, quotes prices in probability space, and runs every order through a risk system that only a person can override.
Kalshi pays people to keep orders resting on its order books. I built a market maker to earn those rewards, and the interesting part turned out not to be the pricing model but everything around it that makes a system safe to trust with money.
Kalshi's monthly volume grew from about $226 million in December 2024 to roughly $29 billion in June 2026, according to Sacra's estimates, after the CFTC dropped its appeal against Kalshi in May 2025. Professional market makers had already started to arrive, and Susquehanna became Kalshi's first dedicated one in 2024.
To make thin markets deeper, Kalshi runs a Liquidity Incentive Program. A resting order earns a share of a daily reward pool based on its size and how close it is to the best price, even if it never trades. The rewards are paid in batches after each program period ends.
My thesis came from a former Susquehanna trader who argued that there is a short window where a programmer who understands trading can earn money by providing liquidity, before the big firms crowd it out. Research points the same way. On Kalshi, people who take liquidity lose about 32% on average while people who provide it lose about 10% (Bürgi, Deng and Whelan, 2025). Being the market maker is the better side of the table, but only if the risk is handled well.
My first Kalshi system, in March and April 2026, tried to be right instead of providing liquidity. It read 18 English and Chinese news feeds, including Reuters, the South China Morning Post, Xinhua, People's Daily and Lianhe Zaobao. Claude read each story, named the Kalshi markets it affected, built a short chain of cause and effect with a confidence level on each step, and estimated a fair probability. Position sizes followed a quarter-Kelly rule with at least an 8-cent edge and no more than 5% of the account in one position, and every chain was checked for circular reasoning.
I ran it in paper mode, and it taught me something that shaped the next system. An LLM can form a view quickly, but a trading edge needs the right price at the right moment, and a handful of calls proves nothing either way. So the next system was built to get paid for providing liquidity instead of for being right.
The list of markets comes straight from Kalshi's incentive program endpoint, which showed about 6,200 reward programs across 477 series on September 4. The bot keeps programs that pay at least $15 a day and markets with at least 48 hours to close, a price between 10 and 90 cents and orders on both sides, and it skips sports and entertainment.
The allocator values each market by its expected share of rewards plus expected income from the spread, minus 1.5 times a risk charge. My share of a reward pool shrinks as I add more size, so the value has diminishing returns. The allocator adds 10 contracts at a time wherever the next dollar adds the most value, up to 70% of the account.
The quoter works in log-odds, so a 5-cent contract and a 50-cent contract get the same width in probability terms. Its fair price blends the midpoint with a size-weighted price and leans up to 3 cents toward heavy one-sided buying or selling. The more inventory it holds, the more it shifts both quotes to reduce that position, by up to 0.35 in log-odds. The half-spread is 0.06 plus 1.5 times volatility plus 0.25 divided by the square root of hours to close, rounded to the one-cent grid and never crossing the book.
The paper trading simulator replays real trades against the bot's resting orders. A trade through my price counts as a fill, and a trade at my price has to use up the orders ahead of mine in the queue first, so paper results are not flattered by fills that would never have happened.
Each version came from something the market showed me rather than from a plan. Version three limited the bot to reward markets and added the allocator and a toxicity monitor. Version four added a live broker with orders that can only rest on the book, and three separate kill switches. Version five moved to Kalshi's newer order endpoint and dropped gas-price markets, which moved too fast to quote safely. Version six came from reading how rewards are actually measured. The reward is scored from a reference price where cumulative size reaches one fifth of the target, not from the best price, so parking one cent better than that level earns the full reward weight while staying away from fills. Version seven was a full redesign of the risk system.
Early testing and a structured design review with a second model surfaced five problems, and each one is the kind that only shows up once a system touches real order books.
The bot counted estimated rewards as income before any reward had been paid. In markets where new information arrives every day, the orders closest to the price were the first to be picked off. One engine file of about 1,100 lines handled strategy, risk, execution and accounting at once, which let a reversed fill direction slip through. The daily halt cleared itself at midnight. And the dashboard could be reached by anyone on the local network.
Version seven answers each one. A state machine moves from observing to shadow trading to armed to quoting, and can fall back to degraded, halted or flattening. Only a person can lift a halt, and a halt needs two confirming snapshots so one bad reading cannot trigger it. Exits happen in stages and can only reduce a position. The bot first joins the best price, then steps one cent every two minutes, and after fifteen minutes it crosses the spread, never paying more than 5 cents of slippage. Every quote also has to pass an expected value check. The expected reward is multiplied by the ratio of rewards actually paid to rewards estimated, and the expected loss from being picked off is subtracted. Until the exchange has paid at least once, that ratio is zero and the strategy runs in shadow mode. Every event is written to an append-only ledger that can rebuild all positions by replaying it, with estimated and paid rewards kept in separate tables, and the dashboard only listens on the local machine.
There is no model in the trading loop, on purpose. Anything that moves money is deterministic and can be replayed, so any fill can be traced to a line of code.
Models were part of how I built it instead. Claude wrote most of the code with me, and Codex reviewed the design in structured rounds, where one side proposes, the other attacks, and every round ends with a written list of disagreements. The second-round document adopted Codex's state machine design, admitted a formula error, and kept six open disagreements on record. I also designed a contract compiler, where a model drafts the settlement rules from a market's rule text, code validates them, and a person signs off before the bot trades that market. That part is designed but not built yet.
The code is private. I am happy to walk through it and the design review behind version seven on a call.
Income you cannot observe is not income. Any system whose economics depend on an estimate needs a gate that treats the estimate as zero until reality confirms it.
The risk system is the product. The quoting model took an afternoon, but the state machine, the ledger and the exit logic are what make it safe to turn on.
Split the engine early. Every serious bug lived where strategy, risk, execution and accounting met inside one file.