The Balance Doctor

A machine that plays Sigilwake against itself, thousands of times a night, listens to the game, measures where it hurts and proposes the cure. This is the story of how we stopped balancing by hand — and of how the same brain that today is learning to fight will one day hold the entire roster in equilibrium.

Act oneThe day we stopped balancing by hand

There is a precise moment when a fighting game stops being an idea and becomes a problem of mathematics.

For us it came on a Tuesday. One character was winning too much. The fix seemed trivial: nudge down the damage of its strongest move, and you're done. Then you stop. Because that character doesn't play alone: it plays against everyone else. Lowering that number weakens it against those who already beat it, and leaves it strong anyway against those who were already losing. Move one tile and twenty-three others tremble. You redo the math. And you realise there's no getting out of it by hand.

From that Tuesday on we began building something we call, as an in-house joke, the balance doctor: a system that listens to the game, measures where it hurts and proposes the cure. This is the first chapter of its story.

The artistic heart that breeds the technical headache

Each of the 24 characters has its own kit: moves, a passive, stats, a distinct combat identity. One absorbs frost and returns it to whoever strikes it. One slowly burns the opponent over time. One controls the mind. They are personalities, not skins. And it is precisely this variety — the artistic heart of the game — that breeds the technical headache.

The problem: a combinatorial nightmare

A competitive game is "balanced" when no character is a mandatory pick and none is useless. Put in numbers: each one, over the long run, should win roughly half the time. Fifty-fifty. It's the point of equilibrium where the match is decided by the skill of the player, not by the bad luck of having drawn the wrong character.

The trouble is how many pairings you have to keep in check at once. With 24 characters, the possible matchups are 552 (each character against the other 23). Any single change — a damage value, a cost, a duration — doesn't touch one duel: it redraws dozens of them in a cascade. It's like tuning an orchestra where every time you tune one instrument you knock twenty others out of key. A human designer, faced with this grid, proceeds by intuition and trial: change something, play a few matches, hope. But a few matches aren't enough to tell a real imbalance from chance. It takes thousands of duels per pairing before the number becomes reliable — and no one has the time to play them by hand.

This grid is the photograph of the nightmare. Five hundred and fifty-two cells, each one a verdict. A human eye gets lost in it. Green that's too intense is a character that crushes; solid red is one that gets crushed. The goal is to bring the whole table towards a uniform shade — neither dominators nor victims — knowing that every brushstroke shifts many others. By hand, it's ungovernable.

The thesis: what if the machine played?

At that point the question flips on its own. If the problem is that it takes too many matches and too much arithmetic, why make a human do it?

What if a machine played the game against itself, thousands of times a night, measured on its own where the scales tip and proposed the corrections?

It's the idea chess players have known for years: a program that plays millions of games against itself learns what works better than any human master. We turned it towards a different end. We don't want an AI that wins: we want an AI that, playing all 24 characters well against all the others, makes the real imbalances surface — the ones you only see when both sides play at their best — and then suggests the recipe to correct them.

The dashboard above is the command deck. Every lap the system runs over five thousand duels — all 552 pairings, repeated — inside a separate environment that never touches the real game. Then it condenses the outcome of those thousands of matches into a single number, which we call NashGap and which you can read as "how far we are from 50-50 across the whole roster". In this snapshot it reads 0.0066, a hair from the threshold we consider "balanced". It's a thermometer. It rises when something gets worse, falls when the cure works. The doctor no longer eyes 552 cells: it watches the fever.

The first step of a larger arc

There's a reason we invested in this and not in a shortcut. Sigilwake is building, in parallel, a next-generation game AI — an AlphaZero-style neural network, the same family of systems that learned chess and Go from scratch by playing against itself. It's the project's flagship technology, the one that will one day pilot opponents at a level a human player struggles to reach.

And here the two roads meet. The same network we're teaching to fight today, once it reaches professional level, will be able to balance the roster on its own. But there's an order to respect, and it's not negotiable: to train that network on a game physics that is genuinely the real one, you first need a clean roster, with no dominators and no victims. A balanced game is the test bench on which the network learns. Show it a crooked world and it will learn to play crooked. That's why the balance doctor comes first: it isn't an accessory, it's the foundation everything else will rest on. We'll return to this link in the final act — it's tighter than it seems.

The system you see today doesn't yet use a neural network — it uses a simpler, more transparent statistical engine, and that's a deliberate choice: first you build the reliable tool, then you supercharge it. But the direction is set. The first brick is this: a machine that plays against itself and measures the game's fever. Let's open the hood.

Act twoThe machine that plays against itself

An experimental ward, isolated from the real game

The classic way to find out whether a roster is fair is to have hundreds of people play it for months and read the complaints. We built something different: a machine that plays against itself, thousands of times for every matchup, inside a sealed experimental ward that never touches the published game.

We call it a sandbox — a word that here means exactly that: a protected pen of sand where you can break everything without consequences. The real game, the one players will run, lives in its own files. The experimental ward works on a copy. The two never touch, by construction. It's the same discipline as a pharmaceutical lab: the experimental drug doesn't reach the ward until someone with signing authority decides it's ready. Here the signature is always a human's. We'll come back to this — it's the point that makes the whole system safe rather than dangerous.

The dashboard you saw in the first act is this ward's control deck. It reads at a glance, like a car's instrument panel. On the left the configuration — the opponent's skill (tier5, the one that plays without mercy) and the ten matches per matchup, which multiplied by 552 pairings make over eleven thousand duels for every turn of the carousel. In the centre the controls, with a single red button: stop the tuning, the big emergency stop that closes the iteration cleanly without leaving anything half-done. And, at the bottom, the only button that touches the published product: promote to the real game, deliberately awkward, guarded by a lock (Force apply) you have to release by hand. Nothing gets promoted by mistake.

NashGap: 0.0066 — our measure of how far the roster is from the perfect 50-50 equilibrium. Take every character, look at how far it strays from winning half its matches, square each deviation (so the big imbalances weigh much more) and average them. The closer the number is to zero, the fairer the game. At 0.0066 we're close, but not yet inside the target we set ourselves (0.005) — and we demand three iterations in a row all green before declaring victory, like a doctor who won't discharge the patient at the first good test.

The overview: watching the iteration breathe

The dashboard says how it's doing. The overview says what it's doing, right now.

At the top, six tiles sum up the session. Then the row that moves before your eyes:

LIVE ITER 4 — 3.165 / 11.040 matches · 28.7% · 23m elapsed · avg turns 19.9 · insta-kill 0

Eleven thousand duels queued, a third already fought. And some quality numbers that are music to a designer: the average match lasts almost twenty turns — not too flash, not eternal — and the hits that kill on the first turn number zero. No one is struck down before they get to play. This is what we want: duels decided by the moves, not by the luck of the draw.

Below, the live ranking of all twenty-four. And here the system's honesty shows at once. At the top, in bright green, glacius at 83.3%. At the bottom, cenere stuck at 37.8%. The vast majority of the roster is gathered between 44% and 56% — most of the squad is already balanced — but the two extremes scream. The system doesn't hide them: it puts them on the front page. A dashboard that only showed the pretty numbers would be worthless.

Scrolling further down comes the diagnostics. The simulated opponent reasons in the blink of an eye — it's a strong and instant player, which makes it credible to play it eleven thousand times in an hour. Then the list that stings: the matchups decided from the start, contests where one character loses every match against another. Zero out of twelve. In chess jargon it's a hard counter: a lost position from the opening, whatever you move. These are the most serious cases, because — as we'll see in the act devoted to the Doctor — they aren't fixed by tweaking a number. They have to be redesigned.

And finally the curve that gives hope: the distance from equilibrium drops iteration after iteration, aiming at the dashed target line. It's the patient's temperature falling. Below, green bars count the changes proposed each lap — at this stage almost all buffs: the system is trying to lift the weak before lowering the strong.

The grid: who beats whom

The ranking says how much each one wins. But it hides a deeper question: it wins against whom? A character at 50% could be honestly balanced — or it could crush half the roster and get crushed by the other half, with the average masking the disaster. To see it you need the full map: the whole-body X-ray you met at the opening, the 24×24 grid of every matchup.

An expert eye reads it like an X-ray plate. The row for glacius is a streak of bright green — it's the strongest patient, the one that makes the game unfair. The row for umbral, at the opposite end, is dotted with reds and zeros: it loses everywhere. And then the extreme cells, those blunt 100s and 0s scattered here and there: the matchups decided from the start, the opening death sentences. The grid makes them all visible at once, in a single image. It's exactly what a human designer would take weeks to compile by hand — and here it regenerates itself at every iteration.

The character of each: not just whether it wins, but how

There's one last question, the subtlest, and for a game perhaps the most important. A character can be perfectly balanced at 50% and still be boring: if it always wins by spamming the exact same move, the numbers are fine but the fun is dead. Statistical balance isn't enough. You need depth.

That's why alongside the win percentage we put three indicators that tell the quality of the play, not just the result:

Choice diversity (H) measures how much a character really uses its whole arsenal. A high value (towards 1,0) means it alternates its four abilities like a boxer who varies his punches; a low value betrays a one-note player. Seraph and tessara shine here (0,95, 0,94): they play rich. Umbral, besides losing, leans on few moves, with a diversity of just 0,71.

Killing-blow concentration (kb): how many wins are closed by the same, identical finishing move. Over 70% triggers the red 1-trick label — the character that has learned a single winning sequence and repeats it. The system prints it plainly on theron, zephyr, seraph. They're balanced on the numbers, but they need to be made more varied.

Dead abilities (dead ab): moves the character, given the choice, never picks. A dead ability is wasted code and a broken promise to the player. Almost every card flags one or two. At the top of the list we find the usual suspects — glacius with its 77,2% and the little warning triangle, then umbral, solaris; at the bottom, centred to the millimetre, raiden.

Why the pen of sand is everything

Let's pause a moment on the point that makes this system defensible and not dangerous. Everything you've seen — the thousands of matches, the grid filling up, the proposed changes piling up — happens inside the sealed ward, on a copy. While the machine grinds through eleven thousand duels, the published game doesn't change by a comma. The team can work on the art, the menus, a new mode, and no one sees the numbers move under their feet.

And the door between the lab and the ward opens only with a human signature. That promote to the real game button, switched off and guarded by the lock, is the only way through. The machine can propose all it likes; applying to the real product is a decision, not an automatism. It's the difference between an assistant that prepares the diagnosis for you and a robot that operates on you by itself. We built the first, on purpose.

This is the machine that plays against itself: tireless in measuring, ruthless in showing the flaws, and by construction incapable of breaking the real game without a human deciding it. It measures where the balance is broken with four different instruments. But in one case — the characters condemned at the opening, the 0% that no numeric tweak can save — even the best of measures stops short. There a more precise thermometer won't help. You need a doctor who redesigns the patient.

Act threeBalance Doctor: from pharmacist to surgeon

We built a doctor for the balance problem. It's called Balance Doctor, and it lives inside a dashboard. Like a real doctor, it works on two levels. The first level adjusts the dosage. The second — the new one, the novelty of this chapter — steps in when the diagnosis is that the patient's anatomy is wrong, and no dosage will straighten it.

The diagnosis dashboard

The Doctor opens with a report-style diagnosis. Then the body of the report: a card for each patient, with the cure already chosen ("chosen patch") and the expected effect. It isn't a list of opinions. It's a list of interventions with a number beside each, like a treatment plan:

• umbral → cost of Dark Claw from 80 to 68 (make it cheaper): estimated impact +5.3 points.
• eclisse → power of Void Arrow from 4.2 to 3.78: about 3.5 points of return towards the band, from above.
• theron → duration of the status effect of Forked Blade from 3 to 4 turns: +5.8 points.
• aurora → cost of Greater Heal from 100 to 85: +5.3 points.

Level one: turning the knobs

The Doctor has a panel of knobs at its disposal — the cost of an ability, how much its damage grows with the character's stat, the duration of a freeze, the chance a hit stuns — and it turns them one notch at a time. No ability is overhauled: you adjust the dose and re-measure. And it works, within its limits: by turning knobs, the doctor brings the majority of characters inside the healthy band.

But here the limit surfaces. The trajectories of the five most stubborn cases tell two different stories: some respond, others stay planted where they are. On certain characters tuning is no longer enough.

When the knobs aren't enough

There's a category of patients on whom tuning not only falls short — it makes things worse. The case that opened our eyes is called boreus, a keeper of the ice designed to absorb blows and return them. On paper an elegant concept. In practice, chronically below the line, and — this is the perverse part — every time we strengthened him, he won less. Lower the cost of his abilities? He gets worse. Raise the power? Worse still.

When every cure makes the illness worse, the diagnosis changes in nature. Boreus's problem isn't the dosage. It's the concept: the way his abilities, his passive and his combat identity fit together is internally contradictory. No knob straightens a crooked anatomy. You need a surgeon, not a pharmacist.

The verifiable piece: the diff

Before we talk about the surgeon, a proof of honesty. Everything the system proposes ends up in a single place, and that place shows real code, line by line, before anything goes to production.

And here you see boreus's redesign, concrete. A new block is added to his passive:

data/abilities.json  vs  overlay/abilities.json      +6 · −0      "flatValue": 15,      "multiplier": 1,      "type": "counter"+    },+    {+      "affectsSelf": true,+      "flatValue": 8,+      "trigger": "cantAct",+      "type": "auraDamage"     }   ],   "element": "gel",

Translated: always-on "thorns". Whoever strikes boreus takes constant return damage, without him having to do anything — consistent with his identity as a defender who punishes whoever attacks him. The intervention is surgical and circumscribed, readable by a human in ten seconds before touching production. This is the proof that the system's output isn't a slide: it's real, verifiable code.

The 3.0 leap: redesign, don't retouch

Boreus's "thorns" aren't a knob turned one notch: they're a redesigned piece of kit. This is the doctor's 3.0 level — to stop tuning numbers and start rethinking the structure of the character.

The surgeon reasons over two knowledge bases we've placed in its hands. The first is the lore of every character: who they are, what element they're made of, what temperament they have, how they fight. The second is the engine's encyclopedia of mechanics: all the building blocks an ability can be assembled from — aura damage, life steal, counterattack, control, shields. With these two books open, the Doctor 3.0 can propose interventions previously out of reach: add or remove an effect, swap an ability, change the condition that triggers it, redesign the passive from scratch, change the archetype, or forge a unique signature.

These are powerful operations — and for that reason dangerous. A crooked number ruins a character; a crooked concept ruins its very idea. That's why the redesign travels with two non-negotiable guarantees:

1. Cite the lore verbatim. Every proposal must hook onto a literal sentence from the character's narrative sheets — not a paraphrase, the exact quotation. It's our antibody against invention: if the system can't find a literal justification in the lore, the proposal is rejected by the validator before it even reaches us.
2. The last word always belongs to a human. No structural redesign applies itself, ever. The proposal appears in the dashboard with two buttons — Approve / Reject — and stays there, paused, until a person clicks. No shortcut, no automatic mode. The blast radius is too wide to delegate to a machine.

None of this is hypothetical. Here is that human veto doing its job — and the machine getting sharper because of it — on a character named neve:

The honest lesson: "design" versus "choose"

It's worth recounting a mistake, because it's instructive. The first version of the surgeon was the most ambitious: give the AI a blank sheet and tell it "design the character yourself from scratch". Elegant in theory. In practice, a disaster of slowness: generation took over four and a half minutes, and most of the time produced no proposal at all — it stalled. A surgeon who deliberates that long over the open patient isn't a useful surgeon.

The diagnosis was precise: it wasn't the fault of the problem's size nor of the environment. It was the task that was too heavy — "design from scratch" is an act of open-ended reasoning, with nothing to hold onto. The fix flipped the approach, and we call it "design → curate": now it's the code that generates a fan of already-valid options — all hooked to the lore, all compatible with the engine — and the AI merely chooses the best one and explains it in plain English. From inventor to curator. Result measured on boreus: from "over four minutes and almost never an answer" to a valid proposal in about 50 seconds, with a safety net that guarantees there's always a proposal. The general lesson: when you ask an AI to reason in a vacuum you pay in time and reliability; when you give it concrete options to choose from, it flies.

The five phases, in one sentence

Under the hood, the 3.0 doctor is five steps in a row: (1) gather the lore of all the characters into an ordered archive; (2) catalogue every engine mechanic into a consultable encyclopedia; (3) build the surgeon's tools — the redesign moves plus the validator that vets them; (4) connect the AI that chooses and justifies; (5) stitch it all into the dashboard, with the Approve / Reject buttons and the mandatory pause for the human signature.

Act fourThe link to the brain: why this doctor trains the champion

There's a question that, at this point, an attentive investor would ask: so what? A balanced roster is nice, but is it the end or the means?

It's the means. Everything the balance doctor does — measuring the win rates, drawing the matrix of who beats whom, computing how far the roster is from equilibrium, proposing the cures — is not a finish line in itself. It's the operating table on which we build the true patient: a game-playing neural network.

What we're really building

In the Sigilwake engine the opponent, today, is piloted by an AI that thinks "by brute force": it examines many moves ahead and picks the best. Solid, but blind to compound strategies, the ones that unfold over ten turns. The next step is a network from the same family that beat the world champions of Go and chess: one part that proposes the moves, one that estimates who's winning, and a planner that explores between twelve and twenty-five moves ahead.

Around this core, three extensions that very few studios allow themselves. A learned world model: the network learns to imagine how the match evolves, move after move, without recomputing every detail of the clash — it dreams the rollouts instead of simulating them. Different personalities for the bosses: the same brain, with a small "style code", plays like an aggressive brute or like a patient weaver of control. Eight personalities from a single model, not eight separate models. And adaptation during the match: a thin layer that tunes itself over the course of the single game, so the end-game boss learns your style in two or three turns and changes gear.

The riskiest piece of integration — running the network inside the game server instead of in a separate service — has already been tried and delivered: twenty millionths of a second per decision, latency under a thousandth of a second even at the 99th percentile.

The precise link: two directions, one brain

That's why balancing isn't a parallel job, but the first rung of the same ladder. The link runs both ways.

Direction one — the balanced roster is the prerequisite for training the network. A neural network learns from data. If you give it matches played on a broken roster — where a character wins in 5% of cases through a design flaw, not through player choices — it doesn't learn to play well: it learns to exploit that flaw. And even after the fix, it takes a great deal of retraining to shed the learned vice. In our internal roadmap this is, literally, prerequisite number one. The same holds for the combat physics: the network predicts on the basis of an internal simulator, and that simulator must match the real engine. Today we measure it constantly — the divergence has dropped to 11,64%, the goal is to bring it below 5%. A surgeon doesn't operate on a blurred X-ray. The balance doctor is what brings the plate into focus.

Direction two — at full maturity, the same network will balance itself. Once the network plays at professional level, you no longer need an external doctor tuning the numbers by hand: the network plays against itself, for every single matchup, measures the win rates and proposes the corrections. The designer signs, or refuses. All the machinery you've seen in the earlier acts — the dashboard, the head-to-head matrix, the per-character trajectories, the Doctor that diagnoses — is the handcrafted version of a process the network will one day carry out on its own. Two capabilities in the same brain: playing at pro level, and keeping in balance the game it plays.

And here is the defensible competitive advantage, said without inflation: very few independent studios have an AI that plays at champion level. Even fewer have one that, on top of that, can balance its own game by itself. The two together, in a product built by a small studio, are rare.

It's not a slide: it runs on real infrastructure

It's worth closing with a note of concreteness, because in this industry it's easy to confuse a roadmap with a rendering. All of this — the balancing loop, the combat servers, the brain to come — lives on top of the same production infrastructure that holds up the game.

The numbers tell of a frugal machine. Dozens of containers, each consuming a fraction of its capacity, all with zero errors in the last sampling window.