Grand Exchange “GE” Terminal

The Grand Exchange is Old School RuneScape’s player-driven commodities market: 4,700+ items, real volatility, visible volume, and nothing but a raw price API to read it with. Grand Exchange “GE” Terminal is the market intelligence terminal I built and run daily, with a layered signal engine, verdicts that explain themselves, and an override that keeps a human in the loop.

Flipping items on the Grand Exchange is a decision-making problem under noisy data. Prices spike and crash hourly, some items dump on predictable cycles, and the wiki’s raw price API gives you the number and nothing else.

GE Terminal answers that with a layered signal engine. It pulls live and historical prices across four timeframes, scores movers on momentum and volume, then runs each candidate through graded buy and sell checklists before anything surfaces as an action.

Grading the market before looking at the signal

A momentum scanner’s failure mode is enthusiasm. Every violent move looks like an opportunity, and the biggest movers are almost always the worst trades; thin, wide-spread items where the move is two people trading at once. So the market gets graded first: range width, volatility, volume, spread, sample depth, each subtracting from a 100-point start. Below 45 an item is graded F, and with the Trade grade ≥ B filter on, F never becomes an action.

The extreme case is a hard stop. If price breaks below its own 7-day floor, the zones the signal was derived from stop being valid, so the label is replaced with BROKEN and the grade takes a −60 penalty, enough to fail an item on its own. It fires rarely, because once an item crashes, the floor moves down to meet it. Most suppression happens in the grading.

Two scales, one word

Two grade systems run in parallel, measuring different things. Trade grade asks whether the item is worth trading at all: range width, volatility, volume, spread, sample depth. It’s a property of the market and it barely moves hour to hour. Signal grade asks whether right now is the moment: three checklist questions, rescored on every refresh. Is this a dip rather than a trend? Is there room to move? Are buyers in control?

Verdicts that explain themselves

A verdict engine weighs 7-day, 30-day, and 90-day percentile position into plain-English calls, from SELL NOW to DON’T SELL, each with its reasoning attached. Nothing appears on screen without a letter-grade and a reason why. Dump detection classifies the drop and measures how long recovery historically takes.

Eighteen-plus versions, running daily, still the tool I trade with.

Early versions had no exit logic at all. I’d buy into something that looked like it was climbing and then sit on it, holding inventory I couldn’t read: no sell zone, no sense of whether it was coming back or whether I should take the loss. That’s where the verdict engine came from, and the recovery window with it. The tool learned to tell me when to get out because I’d already proved I couldn’t work it out myself.

I let six classification systems accumulate in parallel, each with its own vocabulary. Individually every one is defensible; they were added months apart, each solving a real problem.

Each system arrived with a feature, named itself sensibly in isolation, and never got reconciled against the ones already there. Every card is readable. The problem is that fluency doesn’t transfer. Learning what ACCUMULATE means teaches you nothing about what HOLD or WAIT means, even though they’re the same measurement over a different window.

The fix is fewer vocabularies. Zone and Verdict collapse into one percentile scale with a timeframe parameter. Signal grade and trade grade stop surfacing as letters at all and exist only as inputs to tier. Six scales down to three, each one answering something the others can’t: where the price sits, whether the item is worth trading, and whether to act now.

No single naming decision was wrong because each one was sensible when it was made. Across eighteen versions I never asked whether they still added up to one language.

I started this with zero Python background. GE Terminal became a way to learn by building something I’d actually use. Eighteen versions later it isn’t shipped software. It’s built like it expects to be: cached API layers, state persistence, alert thresholds I actually trust.

It’s the first thing I’ve built where I didn’t have to ask anyone to build it.