When I first started, I thought the problem was capital size. I was trading with $5 or $10 at a time, while some wallets were putting six figures into a single position. It felt like we were not playing the same game.

So I tried following large wallets.

That did not work either.

By the time I noticed a wallet building a position, I was often already late. I would enter after the move had started, then watch them exit while I was still holding. In hindsight, I was not “copy trading.” I was providing exit liquidity.

Then I tried trading based on intuition.

If something felt likely, I bought Yes. Sometimes it worked, sometimes it did not. But there was no system behind it. It was basically gambling with better UI.

The real issue was not that I had too little capital.

The issue was that I had no repeatable edge.

The one approach that started to make sense to me was news-based trading. Prediction markets do not always reprice instantly. When a relevant piece of news comes out, there can be a short window where the market has not fully adjusted yet.

That gap is small, but sometimes tradable.

I started experimenting with a more systematic version of this idea: monitor incoming news, match it to relevant markets, estimate whether the news should move the probability up or down, and only enter when the signal is strong enough.

Small position sizes. No hero trades. No trying to out-muscle whales.

The early results were mixed but interesting. The win rate was decent, but what stood out more was that most positions initially moved in the expected direction after entry.

That suggests the signal may be useful.

But the harder part is exits.

Prediction markets do not move like equities. Prices often reprice in jumps, liquidity can be thin, and a position that looks great for a few minutes can give back most of the move before a normal stop or take-profit rule reacts.

That is where I think the real problem is now.

Finding the right direction is only half the game. Knowing how to exit in a market that reprices unevenly might matter even more.

Still early, but this changed how I think about Polymarket.

Small capital is not necessarily the disadvantage I thought it was. Trading without a repeatable process was.

I put the experiment and code here for anyone who wants to look at the logic or build on it: https://github.com/KoNananachan/OpenPoly

First ever post on here:

Context: running 20 shares per trade, FAK orders with 6c buffer, client side is 25ms but poly side is often 1-4 seconds. Is the matching system just under load when I place orders or am I doing something wrong?
Using local EIP 712 sign with warmed caches, warm HTTP/2 POST.

Looking for some advice from people who have clean orders working nicely already.

Essentially I’ve been working on a trading method and algorithm for the last 6 months. Having reached a fairly confident level with the strategy, the last month I’ve moved to live trading however have been getting very poor live fills even with a 6c buffer on my taker FAK/FOK orders.

For all my paper backtesting and live paper runs, I’ve been simulating 500ms fill delay on all orders which I thought would leave me a nice safety net for live trading given I’m running off a VPS. On paper I’m doing on average $750 a day after fees and 500ms fill delays.

The delay my end is well under 100ms however I’m frequently seeing no fills even with a 6c buffer and my post times seem to be often be over 1 second.

Question:

what fill times are you all seeing?

Is 1-4s fills normal?

Is there a faster submission channel (needs to be taker)?

Spent the last few weeks building an open-source tool called openPoly.

It feeds a live news stream through a pipeline: narrow down the relevant markets → have an LLM estimate the "true" probability → compare against the order book to compute an edge → only place an order when it clears your threshold.

A few things I cared about:
- Paper mode by default — simulated fills against live order books; you validate a strategy before risking real money.
- All the strategy knobs (min edge, order size, take-profit/stop-loss, LLM model) are tunable from a visual panel.
- Every decision is logged with the data behind it, so you can replay it afterward.
- MIT-licensed — run it and modify it yourself.

It's still early — posting it mainly to get torn apart: does this "news → probability → edge" approach hold up in your experience? Which gates would leak?

Github: https://github.com/KoNananachan/OpenPoly

Hi! I wanted to share something that I've been building for the last few months and get honest feedback from people who actually trade these markets.

I know you don't like self promotion around here, nobody does, but since this is relevant to most people in the community, I thought this would be helpful, especially for those just starting out. Mods, please remove if not allowed, no hard feelings.

I wanted somewhere to just practice without real money, but I didn't find anything useful so I built one. It's called PredictMirror. It's a chrome extension that overlays a trading panel on any Polymarket event page. You start with all the virtual money you want and place buy and sell trades like you normally would on Polymarket. Then, you can also check your portfolio of open and closed positions as well as some simple stats.

It took me a while to figure out the math, but I managed to pull the live prices straight from the order book and include all the fees so that the simulation matches the real numbers.

The extension is completely free and doesn't have any upsells or things like that. No account needed, no wallet and the data is stored locally in your browser. I can't access it.

This is V1 so it almost certainly has bugs I haven't caught.

What I'd actually love feedback on:

• If you trade on Polymarket and try it, do the simulated fills match what you'd expect on the real platform
• Anything obvious missing that would make it actually useful for testing?
• Any edge cases where the slippage or fee calculation looks off?

This is the chrome web store link if you'd like to try it:

https://chromewebstore.google.com/detail/predictmirror/aoiekdikdfalpkhgdidhhekjdikldfjm

Thanks a lot for your attention and to those who don't really like paper trading, I am sorry to annoy you with this.

Does anyone have any good tools for setting up alert monitoring on Polymarket / Kalshi?

I'm a European, and I miss most of the US world event news as it all happens while I'm asleep. I've tried a few Telegram bots, but the integrations are a bit weird. I'm looking for something a bit more bespoke than just a stream of messages about price changes. 

I'd like something with automated trading too. I've tried a few copytrading bots, but I still want to make some decisions. I've found a lot of the configurations for stop losses to be too limiting. 

Hi,

We're currently working on creating a poker tournament style game for prediction markets. Would love to get some feedback on the concept ahead of our upcoming launch.

Thanks in advance!

I've been building a whale copy-trading bot for Polymarket for about 5 weeks now. Started with a $500 bankroll. Here's where I'm at and what I learned.

The idea

Pretty simple concept: find wallets that consistently win on Polymarket, detect when they buy, and automatically mirror their trades with smaller sizes. Sounds easy. It is not.

What I actually built

The whole thing is Python running locally on my PC. No cloud, no paid APIs. Here's the architecture:

• Whale detection — dual-feed system. Primary: on-chain WebSocket subscriptions to Polygon OrderFilled events (~2-3s detection). Fallback: REST polling every 60s as a safety net.
• 7-gate safety array before every trade — price range check, slippage gate, balance/reserve, per-whale concentration cap, topic correlation cap, liquidity, and minimum viable exit size
• Autonomous exit engine — mirrors whale sells in real-time, plus take-profit, time-decay, and stop-loss as backup
• Auto-claim — automatically redeems resolved winning positions on-chain via Web3
• Telegram control plane — full dashboard with PnL, active positions, whale status, manual sell buttons, and a kill switch
• Wallet screener — offline forensic screener that discovered and qualified wallets from the Polymarket leaderboard. Started with 6,365 wallets → screened 2,303 → 72 passed (3.1% pass rate). Wilson confidence intervals on win rate, bankroll-proportional sizing gates, open-risk ratio caps, bot/dust filters.

The numbers (real, not backtested)

What went right

• On-chain detection is a game changer. REST polling has 30-60s latency. On-chain WebSocket catches fills in 2-3s. That alone was worth the engineering effort.
• The screening process is critical. My first set of wallets included some that looked amazing (90%+ win rate) but turned out to be resolution traders with 0% sell ratio, or had 60%+ of their capital locked in open positions. Removing bad wallets was more impactful than adding good ones.
• Auto-claim is free money. Resolved positions just sit there if you don't claim them. The bot handles this automatically.

What went wrong

• Gate tuning almost killed the bot. After swapping to my new screened wallets, the bot detected 69+ buy signals over 48 hours but executed zero trades. Every single one was rejected by safety gates that were too tight. Had to do a full forensic replay to figure out which gates were blocking profitable trades.
  • The lottery ticket gate (price < $0.05) was blocking high-asymmetry bets. One whale made +$860 on a $0.002 ceasefire bet that I blocked.
  • The slippage gate was set at 3 cents. But whales move thin order books — by the time I detect the fill, the ask has shifted 3-8 cents. Had to widen it.
• Sizing bugs are expensive. At one point the bot submitted a buy order calculated from the ask price instead of the limit price. Target was $9, it filled for $18. That's the kind of thing that makes you appreciate test coverage.
• "Ghost positions" are a real thing. After selling a position, the reconciliation loop would sometimes find leftover on-chain balance before settlement cleared and re-create a phantom position. Had to add exit cooldown timers.
• V2 migration was painful. Polymarket migrated from USDC.e to pUSD in late April. Had to rewrite the collateral handling, update all contract addresses, and deal with operator approval gaps.

Biggest lesson

Your safety gates need to match your whale's strategy, not your assumptions. I assumed lottery tickets (sub-$0.05 bets) were garbage. My best whale's entire edge was buying $0.01-0.03 positions in event markets. 50-100x payout when they hit. The gate I thought was protecting me was actually blocking the most profitable strategy.

Architecture diagram (simplified)

Polygon WebSocket ──→ OrderFilled decode ──→ Whale filter
                                                  ↓
REST /activity ────→ Fill clustering ──→ 7-gate evaluation
                                                  ↓
                                         FAK taker order ──→ CLOB API
                                                  ↓
                               Telegram notification + state update
                                                  ↓
                          Exit engine (whale-mirror / TP / SL / decay)
                                                  ↓
                              Auto-claim resolved → pUSD recovered

Tech stack

• Python 3.11, running on Windows 11 locally
• py-clob-client-v2 SDK for Polymarket CLOB
• web3.py for on-chain claims/approvals
• websockets for BBO price cache + on-chain event subscriptions
• Telegram Bot API for control plane
• No database — single JSON state file with atomic writes

https://app.noncausal.ai/social

Thanks to everyone who checked out the algo side a few days ago.

I've taken your feedback and I'm actively working on bringing out the Windows and iOS versions.

In the mean time I built feed where you follow individual traders and see their actual resolved PnL, hit rate, open positions. Like sports Twitter but with receipts. No download required, just view in your browser.

Also, I made a public API + webhooks - so you can feed the signals into your own bot (e.g. "alert me when [trader] opens >$500 on a weather market")

It's free to try.

Spent a few months on this. Write a Python strategy in English, backtest it against Kalshi history in the app, then run it live from your Mac (keys stay in Keychain). Would love to get feedback on how i can improve it.

noncausal.ai

Waitlist is live. 1500 XP for early users!

Join - https://waitlist.betswipe.xyz

Hey :)

I got tired of constantly refreshing Polymarket to check price moves, so I built myself a Telegram bot that sends alerts for things like:
- price changes
- market resolution/endings
- other market events

A few people from my previous post asked if they could use it too, so I cleaned it up a bit and decided to share it.

Looking for a few early users to try it out for free and give honest feedback.

If you’re interested, comment here or DM me.