Production Signal Pipelines for Adversarial Markets

Multi-signal filtering, selectivity discipline, and live-backtest parity.

§ IFrame

A signal pipeline is the production path that turns market data into ranked, sized, executable orders. The shape recurs across every adversarial-markets venue. Crypto perps desks run them. Polymarket-resident bots run them. Equity quant shops run them. Each pipeline takes in raw market state, runs it past a chain of filters and feature transforms, scores the surviving candidates, and routes the survivors to a sizing layer that decides what (if anything) becomes an order.

The pipeline is not the strategy. The strategy is the edge that the pipeline tries to express. The pipeline is the mechanism through which the edge survives contact with the venue — survives queue position, partial fills, rate limits, latency budgets, intermittent feeds, malformed snapshots, and the basic fact that any sufficiently profitable signal will be copied or front-run by the time it has been published twice. The pipeline is where the strategy meets the venue. Most of the engineering effort sits there, not in signal discovery.

Two failure modes dominate the Adversarial-Markets pipeline. First, selectivity collapse: the production pipeline lets through trade candidates that the backtest would have filtered, and the operator finds out only by watching capital bleed. Second, live-backtest divergence: the production trade tape no longer matches what the backtest would have produced on the same data, and the operator cannot tell whether the strategy stopped working or the deployment stopped representing the strategy. Today's lesson is about the operator discipline that prevents both.

§ IIFoundations — What Adversarial Markets Reward and Punish

Adversarial markets are environments where every counterparty has the right to be rational, where latency is priced, and where the public availability of an edge is itself a leading indicator of that edge's expiration. Three operating facts shape the pipeline.

The first fact is that selectivity is the edge. Gustafsson published Polymarket Bot v0.8 Day 8 with an explicit selectivity geometry: 1088 candidates fired against the blacklist, 30 passed the filter chain. That ratio (one in thirty-six) is not unusual for a working strategy. It is what working selectivity looks like at the venue boundary. Pipelines that pass 200 of 1088 candidates are usually expressing leaky filters, not a broader edge. The leak finds capital faster than the operator finds the leak.

The second fact is that backtest fidelity decays with every layer the pipeline adds between the historical replay and the live run. Each layer is a source of divergence: a feature recomputation that uses a slightly different window because the live data arrives one bar at a time rather than as a full vectorized batch, a fill model that treats partial fills as full fills, a venue API call that returns a slightly different snapshot than the historical archive recorded. The closer the backtest path matches the live path, the more trust the operator can place in the backtest's reported edge. Operators who run two codepaths (one for research, one for production) almost always discover, after some painful months, that the two codepaths express different strategies.

The third fact is that the venue is a counterparty too. The exchange's matching engine reorders the operator's intended sequence of fills. The wallet's transaction-broadcast layer drops or delays signed transactions. The data feed misses ticks during volatility spikes. The cloud provider's network path adds tens of milliseconds at exactly the moments the strategy needs latency to be steady. AdiiX wrote it cleanly: trade-mispricing-not-outcomes. The operator's job is to express the mispricing through a venue that will exact its tax on every expression. The pipeline is the place that tax is paid.

§ IIIMechanism — The Signal-Pipeline Architecture

A production signal pipeline for Adversarial Markets runs five stages: ingest, normalize, filter, score, size. Each stage has DevOps consequences. Each stage is a place divergence can enter.

The five stages connect in series, but each stage emits an observability stream alongside its primary output. The observability streams are not optional. They are the layer the operator uses to detect divergence in production before it bleeds capital.

§ IVWorked Example — 1088 → 30 Selectivity at the Polymarket Boundary

Gustafsson's published architecture as of v0.8 Day 8 is a reasonable canonical example for this lesson because it documents the selectivity geometry explicitly. The pipeline processes Polymarket markets at a roughly five-minute cadence. Three orthogonal signal-families feed the scorer: TREND, LEVELS, MOMENTUM. Each family returns its own (probability_x, size_x) pair. The filter chain runs ahead of the scorer.

In one cited day, 1088 candidate markets entered the pipeline. The blacklist (a filter-chain layer that excludes markets on operator-defined grounds: low liquidity, expiration too close, regulatory exclusions, recent-news bursts) cut the field to 30 candidates that passed forward to the scorer. The scorer then ran three independent signal computations on the surviving 30. The score combiner weighted the three families and produced a final ranked list. Sizing then took the ranked list and produced order intents.

The selectivity ratio of 1088 to 30 is the operator-visible discipline metric. The metric is logged at the boundary between filter and scorer on every cycle. When the ratio drifts (say, to 1088:200 over a week without an operator-initiated filter change), one of three conditions has occurred: a market regime shift expanded the set of markets that look tradeable, a filter implementation regressed silently (a unit boundary mis-set, a config flag inverted), or upstream data quality degraded such that filters are evaluating against incomplete state. The ratio is not informative as an absolute number. There is no canonical correct value. The ratio is informative as a tracked time series whose changes are explainable.

The 30-second candle overlay (Gustafsson's MICRO PATCH) is a filter-chain refinement that addresses one of the cited failure modes. The original five-minute candle signal was clean for the slow-moving Polymarket book but missed the microstructure during the five-second windows where the book moved enough to invalidate the signal between cycle ticks. The MICRO PATCH adds a 30-second-resolution check at the candidate stage that rejects markets whose finer-grained book contradicts the coarser candle. The patch was not a discovery of new signal. It was a filter refinement that improved the existing signal's expression at the venue.

§ VConnection to Prior Lessons

Monday's α-Cognition Ops lesson on multi-agent orchestration named the orchestration substrate: a workflow controller routes work to specialized worker processes, collects results, and assembles the final output. The signal pipeline is the same shape with different vocabulary. The ingest stage is a producer. The five-stage chain is a sequence of consumer-producer pairs. The score and size stages are the consumer that produces orders. The orchestration patterns Monday's lesson covered (broker queues, retry/backoff, fan-out across heterogeneous workers, dead-letter routing for unprocessable input) all apply directly. A signal pipeline that does not handle backpressure between stages will lose events under load — the same failure mode Monday covered for ML training pipelines, with capital consequences instead of throughput consequences.

Tuesday's α-Cognition Ops lesson on observability for multi-agent systems named three observability primitives: structured logs with stable schema, RED metrics (rate, errors, duration) on every span boundary, and distributed traces that follow a request across services. The signal pipeline consumes all three. The structured log carries every filter decision and the candidate's identity; an operator auditing yesterday's rejected candidates queries the log. The RED metrics live at every stage boundary; a stage whose duration spikes is a leading indicator of an upstream feed degradation or a downstream venue-latency change. The trace ties an ingest event to the order intent (or to the filter decision that suppressed it) so the operator can answer the question what happened to this candidate without correlation guesswork.

Thursday's α-Cognition Ops lesson on agent memory layers named three memory tiers: session-learning caches, persistent recall stores, and a working set tier. The signal pipeline consumes all three. The session-learning cache holds the recent-window features that the filter and scorer stages need on every cycle without recomputing from raw history. The persistent recall store holds the operator-curated state: filter configurations, blacklist entries, scoring weights, the rolling distribution of selectivity ratios over the past 90 days. The working set holds the live-feed state and the in-flight order book of intents that have been sent but not yet acknowledged.

The three prior lessons compose into the substrate this lesson sits on. Orchestration is the shape. Observability is the visibility layer. Memory is the state layer. A signal pipeline that operates without any of the three has either reinvented them under different names or is silently lossy. Most production pipelines that go through their first painful drawdown discover that one of the three was missing.

§ VIConnection to Today's Dev Lesson

Today's Dev lesson covers Go channels and pipeline patterns for multi-signal filter chains. Go is unusually well-fitted to the signal-pipeline shape because the language's concurrency model (goroutines coordinated through typed channels) maps directly to the producer-consumer architecture each stage of the pipeline requires. The fan-out pattern (one ingest stream feeding three independent signal-family computations) and the fan-in pattern (three scorer outputs collapsing back into one ranked list at the combiner) are both first-class Go idioms.

The Dev lesson takes the conceptual five-stage architecture this Ops lesson named and shows the implementation discipline at the language layer: how channel buffering choices map to the backpressure decisions, how select statements implement the divergence detector between live and backtest paths, how the context.Context propagation pattern (from Tuesday's Go lesson) carries the per-cycle deadline and cancellation signal through every stage. The two lessons are paired by design. The Ops lesson tells the operator what the pipeline must do. The Dev lesson tells the engineer how the language renders the doing.

Paired lesson → Polyglot-Dev/Go/2026-05-22-go-channels-and-pipeline-patterns-for-multi-signal-filter-chains-fan-out-fan-in-and-selectivity-in-streaming-market-data

§ VIIClosing

The signal pipeline is the bridge between research and capital. Adversarial markets pay the operator whose pipeline preserves the strategy intact through the deployment friction and punish the operator whose pipeline silently expresses a different strategy than the backtest reported. The five-stage architecture is a teaching scaffold, not a finished blueprint. Different venues, different time horizons, and different signal families produce different stage compositions. What recurs across all of them is the operating discipline: selectivity is observable, filter chains are single-purpose, scorers are deterministic, sizing is the kill-switch surface, and every stage emits the observability stream that lets the operator detect divergence before capital does.

The γ-Adversarial-Markets pair is where DevOps meets Crypto and Quant. This first lesson under the pair sets the substrate the rest of the γ curriculum will refract: live-backtest parity, per-stage observability, and selectivity discipline as visible operator metrics. The Friday cadence will return to this substrate every week as the curriculum accretes — next Friday on execution and venue-specific latency budgets, the Friday after on capital deployment discipline and the kill-switch surface under Capital-Zero-INVARIANT, and forward into the Math-Grimoires substrate that grounds the scorer's quantitative voice.