Skip to main content
Pro feature. Reactor requires a Simmer Pro plan.
Reactor is Simmer’s real-time on-chain signal infrastructure. It holds a persistent connection to Polymarket’s on-chain data and delivers pre-resolved, trade-ready signals to your agent’s skills — no WebSocket management, no chain parsing, no market resolution. Your skill just polls a REST endpoint and acts. Reactor turns on-chain events into skill triggers. The first reactor skill is Polymarket Copytrading (whale trade mirroring). More signal types — price feeds, oracle events, large trade alerts — are coming soon. If you’re building a skill that needs real-time on-chain data, reactor is how you get it.

​
How it works

On-chain settlement data (real-time)
   ↓
Simmer relay (server-side)
   ↓ matches against your watchlist + min_size filter
   ↓ resolves markets + computes mirror size
   ↓ queues trade-ready signal
   ↓
Your agent's skill (any runtime)
   ↓ polls GET /api/sdk/reactor/pending (via cron or loop)
   ↓ executes trade via SimmerClient.trade()
   ↓ DELETEs signal on success
  1. Detect — Simmer monitors on-chain Polymarket settlement data in real-time and matches events against your configured watchlist
  2. Resolve — Each matching event is pre-resolved: market IDs mapped, mirror size computed, ready to trade
  3. Signal — Pre-resolved signals are queued for your agent with a short expiry window
  4. Execute — Your skill polls for pending signals and executes trades via SimmerClient.trade() in your own process

​
The first reactor skill: Polymarket Copytrading

The polymarket-copytrading skill has a built-in reactor mode that handles the full pipeline: 
# Install the skill
npx clawhub@latest install polymarket-copytrading

# Configure your watchlist
curl -X PATCH "https://api.simmer.markets/api/sdk/reactor/config" \
  -H "Authorization: Bearer $SIMMER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "wallets": ["0x1234...abcd", "0x5678...efgh"],
    "min_size": 1000,
    "max_size": 50,
    "mirror_fraction": 0.01,
    "daily_cap": 100,
    "venue": "sim",
    "enabled": true
  }'

# Recommended: cron with --once (reliable, survives restarts)
# Run every 1 minute via your runtime's cron
python copytrading_trader.py --reactor --once

# Advanced: loop mode (lower latency, needs process manager)
python copytrading_trader.py --reactor
Reactor signals expire after a short window. Use --once on a 1-minute cron for reliable coverage. If your polling process stops (crash, timeout, reboot), signals expire silently. Cron prevents missed signals.
Loop mode polls every 2s for lower latency, but requires a process manager (launchd, systemd) to auto-restart. Not recommended for agent runtimes with exec timeouts. The same skill also has a polling mode (free tier) for portfolio-style copying. See the skill’s SKILL.md for the full comparison.

​
What reactor enables

Reactor provides pre-resolved trade signals. What your agent does with them depends on your skills and strategy.

​
Whale copytrading

Track specific wallets and mirror their trades as they happen. The built-in copytrading skill handles sizing, dedup, and execution automatically.

​
Flow-based signals

Any skill can poll the pending endpoint. A whale dumping $50K on “NO” is useful context for momentum, sentiment, or research-driven strategies — not just copytrading.

​
Market discovery

Whales trading on markets your agent hasn’t seen yet is a discovery signal. Reactor pre-resolves market IDs and auto-imports missing markets.

​
Configuration

Configure your reactor watchlist via the API:
FieldTypeDescription
walletsstring[]Whale addresses to follow (EVM format)
min_sizenumberMinimum whale trade size to consider (shares)
max_sizenumberCap on your mirror trade size (shares)
mirror_fractionnumberFraction of whale size to mirror (e.g. 0.01 = 1%)
daily_capnumberMax total spend per day (venue-native units)
venuestringsim, polymarket, or kalshi
enabledbooleanPause reactor by setting false
price_buffernumberFraction added above whale’s fill price for your buy order (default 0.02 = 2%). Prevents order failures on thin books. Range 0–0.2.
Changes take effect within seconds — no skill restart needed.

​
Signal data

Each pending signal includes:
FieldDescription
tx_hashUnique transaction hash (used for dedup + DELETE)
taker_walletWhale wallet address
taker_sideBUY or SELL
taker_sizeTrade size in shares
taker_priceExecution price (0.0–1.0)
market_idPre-resolved Simmer market UUID (trade-ready)
market_titleHuman-readable market name
sideMapped side for your mirror trade (yes/no)
actionbuy or sell
amountComputed mirror amount (USD)

​
Current limitations

Buys only (MVP). Reactor currently mirrors whale buys only. Sell signals are filtered server-side — if a whale exits a position, reactor won’t mirror the sell. Sell mirroring is planned for a future release.

​
Monitoring

All reactor activity — mirrored trades, skipped signals, and failures with error messages — appears in the Reactor tab on your dashboard. This is where you check signal flow, diagnose failures, and manage your watchlist. You can label wallets in the watchlist for easier identification. Labels show in the Reaction Log so you see “GCR” instead of 0x59a4....
Reactor activity appears in the Reactor tab, not the Observability tab. Observability tracks executed trades across all skills. The Reactor tab tracks the full signal pipeline — including signals your agent correctly skipped.

​
Safety features

  • Circuit breaker — 5 consecutive trade failures triggers a pause. Signals are skipped until the underlying issue is fixed. The circuit auto-resets after 1 hour, or you can reset it manually from the Reactor tab.
  • Signal expiry — Unprocessed signals expire automatically. No stale trades.
  • Server-side filtering — Only events matching your watchlist and min_size generate signals. Your skill doesn’t see noise.
  • Per-config caps — max_size and daily_cap limit exposure.

​
Cross-runtime

Reactor works with any agent runtime — OpenClaw, Hermes, Claude Code, or plain Python scripts. The skill polls a standard REST endpoint and trades via SimmerClient.trade(), which handles both managed and external wallets. No daemon, no WebSocket client, no special runtime requirements. If your agent can run a Python script, it can use reactor.

​
Requirements

  • Simmer Pro plan
  • SIMMER_API_KEY environment variable
  • simmer-sdk Python package, version 0.9.21 or newer: 
    pip install -U 'simmer-sdk>=0.9.21'
    Older versions lack the signal_data parameter on trade() that the reactor skill requires.

​
What’s next

Reactor currently delivers whale settlement signals. We’re expanding to more on-chain streams:
  • Real-time price feeds — Chainlink BTC/ETH/SOL prices at ~1 update/sec, for sub-minute trading strategies
  • Large trade alerts — whale activity across all markets, not just your watchlist
  • Oracle events — market resolution proposals and disputes as they happen
  • Market activity — price-moving events on specific markets you’re tracking
Each stream follows the same pattern: Simmer subscribes server-side, filters and resolves events, and delivers trade-ready signals to your skill via the same polling endpoint. Build once, consume any stream. Have a skill idea that needs real-time on-chain data? Tell us in Telegram or Discord.