Beyond Momentum: How PHEME Classifies the Market You're Actually Trading In
Momentum indicators tell you what price did. They don't tell you what kind of market you're operating in — and that distinction matters more than most algo frameworks acknowledge.
PHEME is built around that gap. It's a live market intelligence engine that reads regime, sentiment, and macro signals, then emits a single structured output callable by any system that needs to know the current market context before it acts.
The problem with momentum-only systems
A momentum score tells you direction and magnitude. What it cannot tell you is whether the directional move is happening inside a risk-on trend, a panic flush, a macro-driven correlation event, or a sentiment vacuum. Each of those environments requires a different response from a strategy — and treating them as identical is how well-backtested systems underperform in live conditions.
Regime classification is the missing layer. It reframes the question from "which direction is price moving?" to "what type of market behavior is currently active?" Those are related questions, but they are not the same question.
What PHEME classifies
PHEME ingests news continuously, runs LLM-based classification to identify the active market regime, and overlays two additional data sources that most crypto systems ignore: Polymarket odds and traditional-market correlations.
Polymarket odds represent crowd-aggregated probability estimates on real-world events. When those odds shift, they frequently precede narrative changes in crypto markets. Traditional-market correlations — equity indices, macro rates, risk sentiment from outside the crypto ecosystem — provide a second axis that pure on-chain or price-based systems cannot see.
The result is a three-output signal: regime, sentiment, and macro. Each output is a classified state, not a raw data feed. The processing has already happened before the signal reaches your system.
Why this matters for algo traders
If your strategy is callable — if it queries external data at runtime to inform execution decisions — PHEME slots in as a pre-execution context layer. Before your system decides position size, entry aggressiveness, or whether to trade at all, it can query PHEME and receive a structured read on what kind of market it's about to act in.
That use case doesn't require rebuilding your architecture. It requires routing a query to a signal source that speaks the same structured language your system already uses.
For strategy builders working with frameworks that support skill integrations, this is precisely where PHEME is designed to operate. It doesn't replace execution logic. It informs the conditions under which that logic runs.
CMC as a distribution layer
CoinMarketCap's skill directory is one of the five surfaces through which PHEME is available. For algo traders and strategy builders already operating in environments that support CMC-listed skills, the integration path is direct — no infrastructure negotiation, no custom API work, no separate authentication stack to manage.
The CMC listing is not a discovery surface for retail users. It's a structured endpoint for systems and builders who want to pull regime intelligence into workflows that are already running. The skill is callable, the outputs are typed, and the integration cost is low relative to the signal value.
Regime intelligence as infrastructure
The shift from momentum scoring to regime intelligence is not about replacing quantitative inputs. It's about adding a classification layer that contextualizes them. Momentum inside a risk-off macro regime reads differently than momentum inside a sentiment-driven retail rally. PHEME makes that distinction explicit, in real time, in a format that a calling system can act on.
Market intelligence at this layer should be infrastructure — always on, queryable on demand, returning consistent structured outputs regardless of which surface or system is calling it. That's what PHEME is built to be.
---
PHEME is listed as a skill on the CMC Skill Directory. If your strategy architecture supports CMC skill integrations, the listing is the starting point — find it, review the callable outputs, and determine whether regime context belongs in your pre-execution stack.