Teaching the Trading Mind: How InDecision Learns from Every Trade

The name is intentional.

InDecision — the trading component of Knox's system — is named after the thing it's supposed to eliminate. Not hesitation, but the kind of false certainty that makes you trade when you shouldn't. The indecision the name references is the model's own uncertainty about market direction. When the model doesn't have strong conviction, it stays flat. That's the feature.

But the more interesting part isn't how InDecision trades. It's how it learns.

The Six-Factor Model

InDecision runs a six-factor bias model for crypto markets. The factors cover distinct domains of market analysis:

Macro liquidity conditions. The global liquidity cycle is the single most reliable predictor of crypto market direction over multi-week horizons. Dollar strength, global M2 trends, central bank balance sheet trajectory — this is the deep context layer that everything else sits within.

On-chain flow signals. Exchange inflows and outflows, miner behavior, large wallet activity. The chain doesn't lie the way price action can. Smart money moving on-chain before a move shows up on-chain before it shows up on the chart.

Derivatives positioning. Futures funding rates, open interest trends, options skew, liquidation clusters. The derivatives market is where leverage lives, and leverage creates forced moves. Knowing where the forced moves will happen is a significant edge.

Network activity. Active addresses, transaction volume, fee market dynamics. Real-world usage of a network either supports or undermines a price thesis. Divergence between price and network activity is a high-conviction signal.

Sentiment divergence. Not sentiment itself — divergence from what sentiment would predict. When the crowd is maximally bearish and on-chain accumulation is happening, or maximally bullish and distribution is underway, the divergence is the signal, not the raw sentiment number.

Technical structure. Market structure, key support/resistance levels, trend definition. This is the last factor considered, not the first — structure confirms what the other five factors suggest, it doesn't drive the thesis.

Each factor generates a directional signal: bullish, bearish, or neutral. Each signal carries a conviction score between 0 and 1. The six signals are combined using a weighted average where recent accuracy determines the weighting — factors that have been more correct more recently carry more weight.

The output is a composite bias with a direction and a confidence score. High confidence in either direction generates a position. Low confidence or neutral means no trade.

The PolyMarket Application

The PolyMarket bot is InDecision's primary execution environment. Prediction markets suit the model's output structure well — you're not managing position sizing in the same way as spot markets, and the binary outcome structure forces clear directional commitment.

When InDecision outputs a bullish bias with confidence above threshold, the PolyMarket bot looks for active prediction markets that align with that bias. Crypto price markets ("Will BTC close above X by date Y?") get the most activity, but macro markets get attention too when InDecision's macro factor is the highest-conviction component of the composite signal.

Position sizing scales linearly with confidence. The model doesn't have an all-or-nothing mode — it has a conviction spectrum, and position size reflects where on that spectrum the current signal lands.

The bot runs automatically. What doesn't run automatically is the learning cycle.

The Learning Architecture

Most trading bots treat outcomes as just performance data. Win rate, Sharpe ratio, drawdown metrics. Useful for measuring performance, useless for improving the model.

Knox's system treats trade outcomes as training data for reasoning, not just statistics.

Here's the actual flow:

When a position closes — win or loss — the outcome gets packaged with full factor context. Not just "BTC dropped 8%." Instead: what was each factor's signal at entry, what was each factor's conviction score, what was the composite output, what actually happened, and what was the magnitude of the move relative to the model's confidence.

That package goes to Tesseract Intelligence for post-trade analysis. Tesseract doesn't just look at whether the trade made money. It looks at three questions:

Was the reasoning sound? A losing trade with a correctly-identified thesis and unexpected external shock is not a model failure. It's market noise. The rule learned here is about position sizing in high-uncertainty environments, not about the factor that generated the signal.

Which factor failed, specifically? When a loss reflects a genuine model failure — when the thesis was wrong, not just unlucky — Tesseract identifies which of the six factors generated the primary error. Was the macro factor bullish when liquidity was actually tightening? Was the on-chain signal reading accumulation when it was actually exchange deposits? The specific factor matters.

Was this a systematic failure or an edge case? A one-time edge case doesn't warrant a model change. A pattern of failures from the same factor in similar market conditions warrants a weight adjustment. Tesseract identifies which category the failure falls into.

How the Model Actually Evolves

The Sunday cron aggregates the week's Tesseract analysis outputs and runs a weight update cycle.

Factors that generated accurate signals over the past week get slightly increased weight. Factors that generated inaccurate signals get slightly decreased weight. The adjustment is conservative — small deltas to avoid overfitting to recent data. But it's continuous, and continuity is what creates compound improvement.

The weight adjustments aren't the only evolution mechanism. Tesseract's systematic failure analyses can trigger more structural changes — modifying how a factor calculates its conviction score, adding a new sub-signal to an existing factor, or, in extreme cases, flagging a factor for full redesign if it's been consistently wrong across enough diverse market conditions.

Those structural changes go into Asana as tasks. Claude Code implements them. The implementation gets the full project lessons history so it doesn't recreate problems that were already solved. The new version of the factor goes live on the next weekly cron.

The model six months from now will be materially different from the model today. Every trade, every post-mortem, every weight update moves it further from its starting state and closer to something that's been shaped by actual market outcomes.

The Difference Between Optimization and Learning

There's a meaningful distinction between a model that optimizes and a model that learns.

Optimization is about maximizing a metric within a fixed framework. You tune the parameters. You improve the performance on the current regime. When the regime changes, the optimized model breaks.

Learning is about updating the framework itself based on what the outcomes are telling you. The model that learns correctly doesn't just perform better on known scenarios — it handles novel scenarios better because it has a more accurate model of reality.

The retrospective loop in InDecision is oriented toward learning, not just optimization. The goal isn't to maximize win rate on recent data. The goal is to build a model that correctly understands why markets move, so that when the next novel market condition arrives, the model's reasoning is more likely to be right.

Tesseract is doing reasoning analysis, not backtest optimization. The difference shows up in performance when market regimes shift — which they will.

What I've Actually Learned Building This

The hardest part wasn't the technical implementation. It was resisting the temptation to intervene too much.

When InDecision takes a loss, the human instinct is to immediately change something. Adjust a threshold. Override a signal. Modify the weighting by hand. That impulse is almost always wrong.

Systematic learning requires enough data to distinguish signal from noise. A single loss is noise. A pattern across twenty trades in similar conditions is signal. Tesseract's role is to make that distinction so I don't have to — and so I don't corrupt the model with reactive human bias.

The rule I've held to: I can read every Tesseract analysis. I can flag a concern for the Sunday cron to address. I cannot directly modify factor weights between weekly cycles. The model's learning process is its own.

Trusting the process is harder than building it. But the results have been consistent enough that I don't second-guess it much anymore.

The model is getting smarter. The evidence is in the trades.