Picture a small studio with one game out, selling modestly on desktop. Two ideas keep coming up in every meeting: port it to a handheld, or drop the price and run a bigger sale. Each has a champion on the team, and the two of them argue as if the game had one kind of player.
It doesn't. Some people finished the campaign twice. Some bounced in the first hour. Some wishlisted and never bought, and some only play on a laptop on the train. A lower price or a new platform lands differently on each of them, and what's obviously good for one group can cost you another. Most studios keep that picture in their heads, and the heads disagree.
I built the strategy matrix1 to get that picture onto one page, show how much of it anyone actually knows, and check afterwards who was right. The studio in this post is made up, and so are its options. The method is what ships.
One decision, many players
The usual way to weigh two options is a list of pros and cons for each. That works until one group's pro is another group's con. A lower price brings in the wishlisters who were waiting, and it tells the people who paid full price last month that they overpaid. A port reaches players who never sit at a desk, and it takes a season of a small team's attention.
None of that is news to anyone in the room. The hard part is holding all of it at once, in a form the next person can read without sitting through the whole argument again.
The grid
A strategy matrix has three axes. Down one side are your segments, groups of players you name yourself, each with an optional weight for how much it matters to this decision. Across the top are your directions, the options you're weighing, and doing nothing can be one of them. The third axis is the lenses you score on. Every matrix starts with five: fit, revenue, friction, feasibility and risk. You can add your own, like community goodwill or how much the work teaches you for the next game.
Each cell is one segment, one direction and one lens, scored from 1 to 5. Fit, revenue and feasibility count for a direction, and friction and risk count against it. A direction's rollup is a weighted mean across segments and lenses, and it shows what it rests on: its confidence, how much of it is assumption, how many cells are contested, and which cells moved it most. Only scores a person has accepted count.
You can read the matrix as a sheet, one lens at a time, or as a stack with every lens layered on top of the others, where each layer has a plain text summary. Every cell shows its score as a digit, its confidence as a word and its basis as a letter and a shape, so nothing depends on colour.
Evidence or assumption, with a confidence
A grid of numbers is easy to make and easy to trust too much. So every score has to say what it rests on, and there are three choices.
Evidence means the score cites something your studio already holds: an insight from studio memory, one of your documents, a marketing touchpoint, a playtest finding, a row in the sales ledger, a Pulse post, a brainstorm card, or a public fact from market research. Each citation says whether the source supports the score or contradicts it, because sometimes it does both.
Inference means the score was worked out from cited evidence instead of read straight off it. Say your playtests keep finding that new players get lost in the first map. Friction for the bounced-early segment on a handheld, where the screen is smaller, is probably worse.
Assumption means nobody has evidence yet. That's allowed, and I think it's the most useful label in the matrix, because it tells you where to look before you commit. A direction whose rollup is mostly assumption isn't a bad direction. Nobody has examined it yet.
Every citation is checked when it's written, against your own studio or, for a market fact, against the public fact base. Only a reference is kept, never the text, and a score can't point at evidence you don't have. If a market fact a score cites is later disputed or superseded, the cell gets flagged so you can look again. The score stays as it is until you change it.
Branch and compare
Most decisions come with a what if. What if the port slips a quarter? What if the sale price lands lower than planned? A scenario is a branch of the matrix. It can rescore the cells you change, and it can carry rules that move a whole row, column or lens by a few points, like raising risk by one everywhere. Everything else stays on the base.
Compare a scenario with the base and the diff lists every cell that moved, from what to what, and why: rescored in the scenario, moved by one of its rules, or scored only there. You also get every direction's rollup and rank, before and after. The number at the bottom matters less than what you can now see before the meeting ends, like a slipped port mostly hurting one segment you care about a lot and barely touching the rest.
Predict, then check
When you choose, record the decision: the direction, the scenario it was made under if there was one, your reasoning, and the predictions that would tell you it worked. A prediction is a metric, a comparison, a threshold, a date to judge it by and how likely you think it is. "Day 7 retention on the new platform is at least as good as on desktop by the end of the quarter, and I think that's more likely than not" is a prediction. "The port goes well" isn't.
Then resolve it, once. Day 1 and day 7 retention, new players and a touchpoint's lift are pulled from your own data when you ask. Units sold and net revenue come from the title's sales ledger, and only after the prediction's date is over, because a ledger that's still filling in would give you a number that's about to change. Revenue stays in the currency it was recorded in. It's never converted and never typed in. If the ledger can't give a clean total, because it mixes daily and monthly rows, holds a month only partly inside the window, or has rows that didn't report the figure, the pull says so instead of guessing. Anything else, and any prediction about one segment, you enter by hand.
Over time, calibration compares what you predicted with what happened, as a hit rate and a Brier score across your resolved predictions. It waits for at least five before it reports a number, and it tells you it's waiting. This is the part I wanted most: after a year you'll know whether your confident calls deserved the confidence.
Where the partner helps, and what it costs
The partner, the same one that sits beside your brainstorm boards, can suggest segments for a matrix from what your studio already knows, or suggest scores for one direction at a time, citing the sources it was shown. Each suggestion is one shared AI unit, the same unit a Design chat turn uses, and it draws your included monthly allowance first.2 The dialog names the unit before anything is spent, and if the partner suggests nothing new, the unit comes back.
A suggested segment joins the matrix only when a person adds it. Every score the partner writes stays proposed until a person accepts it, and it never overwrites a score someone already accepted. A suggested score that doesn't cite one of the sources it was shown is stored as an assumption, so a model's opinion can't pass as evidence.
There's no button to fill the whole matrix in one step. One direction at a time keeps each suggestion small enough to actually read.
Building the matrix, scoring it yourself, scenarios and decisions are included.
Over MCP, and the open core
Your own agent can work with the matrix over MCP.3 It can list your matrices, read one with every cell and its citations, diff a scenario against the base and list your decisions. With a token an owner has allowed to write, it can create a matrix, add segments and directions, set a score and resolve a prediction. Each call is metered as a programmatic read or write on the event meter. Partner suggestions, scenarios, recording a decision and deletes stay in the dashboard. A direction written over MCP carries no price, so an agent can't set one, and money outcomes always come from the sales ledger.
The scoring core is a separate MIT package, on GitHub and npm as ravensight-matrix.4 It holds the schema, the rollup, the gaps, the scenario diff and calibration, with no I/O, as CommonJS or an ES module, so the dashboard and the server compute the same numbers from the same code.
What it doesn't do
It doesn't forecast anything. The matrix holds your scores and your evidence, and the numbers at the bottom are only as good as what went into the cells. It doesn't know your players better than your data does, and it won't make the decision for you.
Calibration also needs outcomes, and outcomes take time. If you record your first decision today, you won't have a meaningful hit rate for months, and the matrix will tell you that instead of inventing one.
What you get is the shape of the decision: who it helps, who it costs, how much of that you know and how much you're hoping. Then it keeps the receipt, so the next decision starts from what the last one actually did.