DEV Community: Vitoshi

We Lost $323. Then We Found a 75% Win Rate. Here's Everything That Happened.

Vitoshi — Sat, 18 Apr 2026 12:25:51 +0000

Originally published at nulllimit.gg/blog/kalshi-trading-bot

This isn't a hedge fund story. There's no VC money, no quant team, no Bloomberg terminal. It's two of us — me and Mewtwo, my AI ops agent powered by Claude — building an automated trading engine from a Lenovo ThinkCentre M75n running Ubuntu in my living room.
The target: Kalshi's binary prediction market for Solana price movements. Specifically KXSOL15M — will SOL's price be higher in the next 15 minutes? You bet YES or NO. You're right or you're wrong. No hedging. No partial positions.
For an AI system, that's actually perfect. It's a pure classification problem. The question was whether we could design one good enough.

Phase 1: Paper Trading (April 4–12)
Before we risked a dollar, we built a scoring engine using 8 technical indicators: RSI, EMA crossovers, Volume Spikes, Momentum, Bollinger Bands, HTF Alignment, Order Book Imbalance, and Sentiment Analysis. Each signal contributes points to a directional score. When the score passes a threshold, the system places a bet.
We ran 69 paper trades. The patterns were clear immediately.
Session Breakdown:
SessionWin RateDecisionNY Afterhours68%Golden window — keepNY Market59%Keep, raise thresholdNY Evening38%DisabledNY Overnight38%Disabled
Direction Breakdown:
DirectionWin RateDecisionUP signals69%KeepDOWN signals45%Disabled
The biggest decision: we had added a hard RSI filter to skip trades when RSI was in a danger zone. Logical. Protective. And completely wrong. Out of 11 trades the filter blocked, 10 would have been winners. 9% accuracy rate. We deleted it immediately.

Your best defense can sometimes be your worst offense. The RSI filter was logically sound. It had a 9% accuracy rate. Delete it.

Phase 2: The Technical Hell of Going Live (April 12–15)
Going live was supposed to be simple. Write live-trade.js, flip a switch. It took 3+ days of debugging before the first real trade landed.
Problem 1: live-trade.js didn't exist. The previous AI session had described building it. It never actually wrote the file. When the first qualifying signal fired — crash. File not found.
Problem 2: Kalshi ask prices returning undefined. The /markets list endpoint returns prices as yes_ask_dollars — dollar values, not cents. We were looking for the old format. Fixed by reading yes_ask_dollars directly.
Problem 3: Markets were "initialized" but not tradeable. Kalshi creates markets in advance with status initialized. These show yes_ask_dollars: 0.0000. Fixed by filtering for openTime ≤ now < closeTime and checking ask price after a secondary fetch.
Problem 4: Trades never resolved. Kalshi marks filled orders as status: "executed" with settlement_status: "N/A" — not "filled" and "settled" as our code expected. Fixed by falling back to price-movement resolution.
Problem 5: balance.json kept resetting to $500. A subtle bug in loadBalance() was re-creating the default balance on certain error conditions. Added explicit try/catch with logging.
Problem 6: Cron job was reading the wrong file. The payload was reading from pre-check.js instead of running radar.js. The bot wasn't actually trading. Fixed.

Phase 3: The Losing Streak
5 consecutive live losses. $323 lost. Balance: $167.84.

DateDirectionScoreSessionP&L1Apr 13, 6:55 PMUP65Afterhours−$124.462Apr 14, 9:50 AMUP70NY Market−$49.883Apr 15, 5:20 PMDOWN75Afterhours−$49.404Apr 15, 6:10 PMUP60Afterhours−$49.505Apr 15, 6:40 PMUP60Afterhours−$49.68

Trade 1 used $124 sizing — we hadn't fixed the 25% compounding logic yet. Trades 4 and 5 had RSI overbought conditions and price above the Bollinger upper band. We were taking UP signals in conditions that directly contradicted an UP thesis. That's not a bad market. That's a bad system.

Phase 4: 15 Optimization Rounds in One Day
We built a backtesting system from scratch. The Node.js version crashed repeatedly. We ported it to Python — it hit errors. We ported it back to Node.js. Then we ran 15 rounds of optimization.
RoundWin RateTradesNotes151.16%215Initial run — coin flip2–422%19–27Too strict, mostly losses5–6—0Filters too aggressive7–850.0%182Breakeven with both directions10–1149.73%185Stuck at coin flip12—0Over-optimized to nothing
After Round 12 we realized: this is not a filtering problem. RSI, EMA, Bollinger Bands, Momentum — these indicators consistently produced a 50% win rate across all parameter combinations. The signal set doesn't have a predictive edge. Everything had to change.

Phase 5: The Radical Shift (Round 13)
We threw out every indicator we'd built and started over with price action patterns and mean reversion logic.
The new signal set:

Bearish Engulfing → DOWN (+100 pts): A large red candle that completely engulfs the previous green candle.
Bearish Pin Bar / Shooting Star → DOWN (+80 pts): Long upper wick, small body. Price rejected hard at the highs.
Extreme Undershoot vs 50-EMA → UP (+120 pts): Price significantly below the 50-period EMA. Mean reversion pull toward fair value. Our strongest single signal.

Round 13 results: 4 trades, 4 wins, 100% win rate. Too few trades — but the direction was clear. We relaxed the filters.
Round 14: 203 trades, 57.64% win rate, +$310.
Then we got surgical. We removed every signal and session that wasn't pulling its weight:
RemovedWRReasonBullish Engulfing33%Liability — actively hurting usBullish Pin Bar52.94%Not strong enoughNY Market session50%Coin flip — cut itExtreme Overshoot62.96%Below thresholdNY Evening57.69%Below threshold
Final result: 97 trades, 75% win rate, +$330 PnL, 6% max drawdown.

The Final Deployed Strategy
Active Signals:

Bearish Engulfing → DOWN (+100 pts)
Bearish Pin Bar → DOWN (+80 pts)
Extreme Undershoot vs 50-EMA → UP (+120 pts)

Active Sessions:

NY Afterhours (4–8 PM EDT): 71.43% WR
NY Overnight (midnight–9 AM EDT): 75.61% WR (+20pt bonus)

Filters:

HTF 1-hour trend: skip UP if bearish, skip DOWN if bullish
Score threshold: 70+

Risk Management:

Base trade size: $10
Compounding: +25% of last win
Max size: $500
3 consecutive wins → reset to $10
20% drawdown from peak → cap at $10

What This Actually Teaches

Live testing before backtesting is expensive tuition. We lost $323 learning lessons that a proper backtesting system could have taught us for free. Build the backtester first. Always.
Lagging indicators don't predict — they describe. RSI, EMA crossovers, Bollinger Bands, Momentum — across 15 optimization rounds, every combination landed at 50%. Price action patterns and mean reversion proved genuinely predictive.
Session matters more than signal quality. NY Market — the "obvious" trading window — was our worst performer. Overnight and Afterhours were where the edge lived. The market behaves differently when Wall Street isn't watching.
Directionality asymmetry is real. DOWN signals were consistently unreliable from day one. Mean reversion UP was our strongest single signal. Don't fight the asymmetry — disable what doesn't work and double down on what does.
AI + human collaboration actually works. Mewtwo wrote 95% of the code and ran all the analysis. I provided strategic direction, caught errors the AI missed, and made the calls on when to pivot. Neither of us could have done this alone at this speed.
Persistence past Round 12 is the whole game. We rebuilt the backtester three times. We ran 15 optimization rounds in a single day. We nearly gave up after Round 12. Round 13's radical shift changed everything. The breakthrough was one pivot away.

What's Next
The strategy is deployed. The bot is live on the M75n, running every 5 minutes, placing real orders. The backtested edge is 75% — now we need live validation across 30+ trades to know if that holds in production.
If it does: Can this apply to other Kalshi markets — BTC, ETH, macro events? Can the mean reversion logic generalize to Polymarket or Metaculus? What happens when we expand the candle pattern set?
The bot is running. The results will tell us if we were right.

Want to build your own autonomous system?
This entire engine — architecture, debugging, strategy discovery — was built by one human and one AI in under two weeks. The barrier isn't capital or education. It's the willingness to build something that might not work, test it ruthlessly, and iterate.
→ Get an AI agent setup: nulllimit.gg/agents
→ Read the full framework: nulllimit.gg/ebooks

Tags: AI Agents · Trading Bots · Kalshi · Builder Playbook · Prediction Markets · Backtesting · Autonomous Systems

We Built an AI Trading Bot in 2 Weeks — Here's What Actually Happened

Vitoshi — Wed, 15 Apr 2026 13:56:03 +0000

The Setup

Two weeks ago, I had an idea: What if I could build an AI system that predicts 15-minute price movements of Solana on Kalshi (a prediction market platform)?

Not a full trading algorithm. Not a crypto hedge fund. Just: can an automated system, using real technical signals + real-time sentiment analysis, consistently predict whether SOL goes up or down in 15 minutes?

By April 12, 2026, the answer was yes. The system is live. It's trading real money. It's winning 55% of the time overall, and 69% when it focuses on what actually works.

Here's what actually happened — not the polished version. The real one.

The Idea (April 4)

Kalshi runs binary markets. You bet "yes" or "no" on whether something happens. For crypto, they offer KXSOL15M — a market that resolves to YES if SOL is higher in 15 minutes, NO if it's lower.

Most retail traders hate binary markets because you're forced to pick a direction. No hedging. No sizing down. You're right or you're wrong.

But for an AI system, that's perfect. It's a classification problem: given all available data right now, will the next 15-minute candle close higher?

I sketched out 8 signals:

RSI (overbought/oversold)
EMA crossovers
Volume spikes
Momentum
Bollinger Bands
Higher timeframe alignment
Order book imbalance
Sentiment analysis (via Perplexity + Gemini LLM)

Combine them, score directionally, place a bet when confidence is high.

That's the engine.

Week 1: Everything Seemed Smart (April 5-7)

I built pre-check.js (the signal scorer), analyze-sentiment.js (the LLM layer), and paper-trade.js (simulate trades without real money).

The first few trades were winners. I was gassed. The signals were working. The sentiment analysis was firing. Everything looked intelligent.

Then I added a hard RSI filter. The logic was airtight: "If RSI is in a danger zone, skip the trade."

I paper-traded for a week with that filter active.

The result? Out of 11 filtered signals (trades I didn't take because of the RSI gate):

10 would have been winners
1 would have been a loser

The filter I was sure would protect us had a 9% accuracy rate.

It was killing winners to avoid one loser. I deleted it on April 7.

That decision alone taught me more about real trading than a year of reading about it. Your best defense sometimes is your worst offense.

The Data Starts Talking (April 8-10)

I ran 69 paper trades. The stats engine broke down performance by:

Session (NY Market, NY Afterhours, Evening, Overnight)
Direction (UP vs DOWN)
Score bracket (60-64, 65-69, 70-74, 75-79, 80+)
Signal combination (which signals fired together)

The patterns were obvious:

Session breakdown:

NY Afterhours: 68% win rate (THIS IS THE GOLDEN WINDOW)
NY Market: 59% win rate
NY Evening: 38% win rate
NY Overnight: 38% win rate

Direction breakdown:

UP signals: 69% win rate
DOWN signals: 45% win rate

DOWN was a coin flip. UP was actually profitable. I could've spent months trying to make DOWN work. Instead, the data said: disable it.

Score bracket:

60-64: 50% win rate
65-69: 50% win rate
70-74: 54% win rate
75-79: 75% win rate
80+: 80% win rate

Higher scores = higher win rates. The system was working.

The Risk Management Layer (April 10)

By April 10, the engine was winning, but compounding was risky. After a 3-trade winning streak, the balance had compounded from $500 → $781. Then a single loss at full size brought it back to $585.

I added three risk rules:

Rule 1: Drawdown Protection
If balance drops 20% from peak, cap all trades at $50 until recovery. Prevents catastrophic blowout during losing streaks.

Rule 2: Consecutive Loss Cooldown
After 2 consecutive losses, pause trading for 30 minutes. Forces the system to step back instead of revenge-trading.

Rule 3: Consecutive Win Reset
After 3 consecutive wins, reset the next trade to $50. Locks in compounded gains before re-exposing larger capital.

Each rule was added because the data showed a near-disaster that happened when I didn't have it.

Going Live (April 12)

By April 12, I was confident. The system had been tested on 69 paper trades, the risk management was solid, and the data was clear about what worked (UP in NY Afterhours at high confidence).

I wrote live-trade.js — the script that places real orders on Kalshi — flipped the LIVE_TRADING_ENABLED flag, and went live with $500.

The system is now running 24/7 on a Lenovo ThinkCentre M75n running Ubuntu. Every 5 minutes, it:

Fetches SOL price data from Binance
Calculates all 8 signals
If confidence is high, fetches news sentiment via Perplexity
If the LLM agrees, places a real order on Kalshi
When 15 minutes pass, resolves the trade and updates balance

Total API cost: less than $1/day. Most of that is Perplexity. Gemini Flash is effectively free at this volume.

What This Actually Teaches

Most posts about "building an AI system" skip the ugly parts. They skip the filters that don't work. They skip the directional asymmetry that contradicts your intuition. They skip the moment you realize your best idea was your worst idea.

This is the real story.

The framework works:

Build something that has a theory behind it
Test it on simulated data
Look at the breakdowns — session, direction, confidence level, signal combinations
Delete everything the data says isn't working
Add risk management in response to real near-disasters, not hypotheticals
Go live when you're confident, but small enough that you're still testing

This isn't specific to trading. This is how you build any autonomous system — whether it's a trading bot, a customer service AI, or a content generation engine.

You have an idea. Data tells you what's working. You ruthlessly remove what isn't. You compound what is.

What's Next

The engine is live and running. I'm monitoring it daily. Once we have 30+ live trades with strong performance in NY Afterhours, we'll know if this actually works with real money (psychology, slippage, all the things that change between paper and live).

If it does, the next questions are:

Can we apply this to other markets on Kalshi? (BTC, ETH, macro events)
Can we build prediction market bots for other platforms? (Polymarket, Metaculus)
What happens when we expand the signal set?

But that's future work. Right now, the bot is live. The code is running. The results will tell us if we were right.

For Builders Reading This

If you're building your first autonomous system — whether it's trading, content generation, or anything else — here's what matters:

Get to a testable version fast. Don't spend months perfecting signals. Build something that works 60% of the time and iterate.
Let the data kill your ideas. You will have smart ideas that the data proves are dumb. The RSI filter was logically sound. It had a 9% accuracy rate. Delete it.
Add risk management in response to real problems, not hypotheticals. The consecutive win reset wasn't in the original design. A 3-trade streak compounding too far made it necessary. Let reality inform your architecture.
Go live small. Paper trading is useful but it's not real. $500 on Kalshi teaches me more than 1000 paper trades ever could.

If you want to build your own AI system (trading or otherwise), the infrastructure is out there. Kalshi's API works. Perplexity's API works. Gemini Flash costs pennies. Your laptop can run it 24/7.

The barrier to entry isn't capital or education. It's the willingness to build something that might not work, test it ruthlessly, and iterate.

That's the actual moat.

Vitoshi | @devCharizard

Built a BTC trading radar, Mewtwo (ops agent), and now this. The pattern is the same: code a hypothesis, run real data through it, delete what doesn't work, compound what does.

Want to build your own AI system? Start here: nulllimit.gg/agents — fully configured AI agent setup for whatever you're building.

Or if you want the full framework for your first autonomous system: nulllimit.gg/ebooks — the complete guide.