Nothing Ever Happens: Open-Source Polymarket Bot

What Is Nothing Ever Happens?

Nothing Ever Happens Polymarket Bot is an open-source async Python prediction market bot built by sterlingcrispin for Polymarket traders, indie hackers, and Python developers who want to automate NO-side entries on standalone non-sports yes/no markets. Nothing Ever Happens is one of the best Prediction Market Bots tools for Python developers because the runtime enforces three explicit live-trading gates and falls back to paper execution unless all of them are set.

The repo is organized for operators, not hobbyists: bot/ holds runtime, exchange clients, dashboard, recovery, and the nothing_happens strategy, while scripts/ and tests/ cover deployment helpers and regression checks. The design is narrow on purpose, which makes it easier to reason about order flow, state recovery, and wallet requirements.

Quick Overview

Who Should Use Nothing Ever Happens?

• Polymarket operators who want a focused NO-bias strategy on standalone yes/no markets without writing market filters from scratch.
• Python engineers who prefer a readable async codebase with explicit paper/live separation and a small operational surface.
• Indie hackers running low-maintenance experiments on Heroku who need shell helpers, local config files, and a dashboard they can inspect fast.
• Automation-minded traders who care more about guard rails and recovery state than about a broad strategy zoo.

Not ideal for:

• Traders who need multi-asset crypto execution, cross-exchange routing, or order-book market making.
• Users who want sports markets, binary options across multiple venues, or long/short portfolio automation.
• Teams that need a fully documented commercial support contract or enterprise compliance package.

Key Features of Nothing Ever Happens

• Standalone market scanning - The runtime looks for standalone non-sports yes/no markets and filters for NO entries below a configured price cap. That keeps the strategy tight and makes the decision rule easy to audit.
• Paper-first safety model - If BOT_MODE=live, LIVE_TRADING_ENABLED=true, and DRY_RUN=false are not all present, the bot uses PaperExchangeClient. That means a bad deploy defaults to simulation instead of sending real orders.
• Live-mode wallet requirements - Real trading also needs PRIVATE_KEY, DATABASE_URL, and POLYGON_RPC_URL, plus FUNDER_ADDRESS for signature types 1 and 2. Those guards matter because proxy-wallet approval and redemption are on-chain actions.
• Recovery state persistence - The runtime tracks open positions and stores live recovery state when order transmission is enabled. That makes restarts safer because the bot can rehydrate operational state rather than pretending the process never died.
• Dashboard-driven operations - python -m bot.main starts the runtime and exposes a dashboard on $PORT or DASHBOARD_PORT. For operators, that is faster than SSHing into logs for every state check.
• Heroku-oriented workflow - The repo includes alive.sh, logs.sh, live_enabled.sh, live_disabled.sh, and kill.sh for deployed instances. That is a practical set of controls for small teams that ship from Heroku instead of Kubernetes.
• Config split between secrets and non-secrets - config.json holds local runtime settings, .env holds secrets and runtime flags, and CONFIG_PATH can point at a different config file. That separation keeps operational edits from polluting git history.

Nothing Ever Happens vs Alternatives

Pick Nothing Ever Happens when your workflow is opinionated and Polymarket-specific. Pick Hummingbot when you need a wider trading engine across exchanges, and pick Freqtrade when your input data is standard crypto candles rather than market outcomes.

If your bigger problem is observability, pair this bot with OpenTrace so order flow and operational state are easier to inspect. If you need exportable state and table snapshots around the live wallet, DataHaven fits the same operator mindset.

How Nothing Ever Happens Works

Nothing Ever Happens uses a small runtime centered on the nothing_happens strategy, which scans supported markets, checks the configured price cap, and decides whether a NO order is worth placing. The codebase separates runtime logic from operational helpers, which is the right shape for a bot that has to survive restarts, inspect live positions, and keep a paper-trading fallback available.

The architecture is intentionally defensive. A live order only leaves the process when the environment proves that the operator really meant to trade, and the runtime can persist recovery data when live transmission is on. That design prevents accidental execution from a half-configured .env file and gives you a clearer failure mode when wallet, chain, or database dependencies are missing.

BOT_MODE=paper DRY_RUN=true python -m bot.main

That command starts the runtime in a safe mode and brings up the dashboard without requiring a funded wallet. Expect the bot to scan according to config.json, then show state in the web UI while keeping live exchange actions disabled until the full live-trade flag set is present.

Pros and Cons of Nothing Ever Happens

Pros:

• Explicit live-trading guard rails reduce the chance of accidental real orders from an incomplete deploy.
• PaperExchangeClient fallback gives you a safe default for local testing and regression work.
• Focused strategy scope makes the code easier to audit than a giant general-purpose trading engine.
• Dashboard plus scripts cover the main operator workflows without requiring bespoke tooling.
• Recovery state support is useful when a bot has to survive process restarts or Heroku dyno churn.
• Test coverage exists in tests/, which is better than a repo that only ships a README and a dream.

Cons:

• Single-strategy scope means this is not a general trading platform.
• Live mode has many prerequisites and will not work unless wallet, chain, and database settings are all correct.
• Heroku-first workflow is practical for small deployments, but not every team wants dyno-based ops.
• No sports market support limits the addressable use case by design.
• The page does not expose license, star count, or release metadata, so due diligence still requires checking GitHub directly.

Getting Started with Nothing Ever Happens

The quickest Nothing Ever Happens tutorial is a paper-first local install: install dependencies, copy the example config, copy the example environment file, and start the runtime. The repo explicitly keeps config.json local and ignored by git, which is the right default for a bot that may eventually contain secrets, wallet addresses, and market preferences.

pip install -r requirements.txt
cp config.example.json config.json
cp .env.example .env
python -m bot.main

After that, the dashboard should bind to $PORT or DASHBOARD_PORT if one is set, and the runtime will use paper execution unless the live-trade flags are fully enabled. If you later move to Heroku, the provided shell helpers and heroku config:set commands are enough to promote the same code path into a live dyno with the same config split.

Verdict

Nothing Ever Happens is the strongest option for Polymarket NO-side automation when you want paper-first safety and a narrow standalone-market strategy. Its biggest strength is the explicit live-trading gate; its main caveat is that it solves one workflow instead of becoming a generic trading framework. Use it if you want a purpose-built Polymarket bot, not a broad market engine.