How it works

EDH Seer claims that two cards work together only when it can print the sentence that says why. This page is how that sentence gets made, and what the engine refuses to say when it cannot make one.

34,433

cards read from oracle text

71

real decks it is calibrated against

0

model calls when you analyse a deck

The model runs once, offline

A language model is used exactly once per card, months before you paste anything, to turn printed oracle text into structured clauses. It never runs at analysis time. That is not a cost-saving detail — it is what makes the tool answerable: the same decklist always produces the same report, every claim can be traced to a rule, and the whole analysis runs in your browser with no server to ask.

The structuring pass is deliberately narrow. It is asked to say what a sentence is — a trigger, an effect, a subject — never whether two cards are good together. It is a parser, not a judge.

1. Oracle textwhat is printed on the card
2. Segmentone sentence at a time
3. Normalizethe model, once per card
4. Deriveclauses become events
5. Matchsupply meets demand
6. Reporta sentence per claim

The one step that costs money, and the only one a model touches. Everything after it is deterministic and free to run again — which is what makes a wrong claim fixable rather than permanent.

What a clause looks like

"Whenever another creature you control enters, it gets +2/+0 and gains haste until end of turn" becomes a trigger (enters, on a subject that is a creature you control and is not this card) and an effect (pump, amount +2/+0). "Create a 1/1 red Goblin creature token" becomes an effect (token-generation) that emits two events: a token being created, and a creature entering the battlefield.

Every card ends up with two lists: the events it produces, and the events it cares about.

How an edge forms

One card's produced event is matched against another card's demand. Both sides carry filters, and all of them have to agree: the card type and subtype, who controls it, whether it is a token, whether it arrives tapped, which counter it carries. Krenko, Mob Boss emits "a creature you control enters, and it is a token"; Impact Tremors demands "a creature you control enters"; the demand is satisfied, so the edge exists and the report writes the sentence.

The filters are where the engine earns its keep, and where it is most often wrong in an interesting way. A card that fetches "a Plains, Island, Swamp or Mountain card" produces a land entering — so it must not satisfy "whenever another creature you control enters", even though one Magic card in history is a Land Creature with a basic land type. The rules that decide this are ordinary code, reviewed against the Comprehensive Rules, and every one of them is a place a bug can live.

What it refuses to claim

• Roles are not synergies. Ramp, removal, card draw and tax make a deck work without pairing with anything in it. They are counted as slots against a target, never drawn as edges — otherwise a single cost reducer forms an edge with half the deck and says nothing.
• A card that names itself means itself. "This creature", "this spell", the card's own name. Reading those as a class was once responsible for roughly three quarters of all false edges.
• Playing Magic is not a synergy. "Whenever you cast a spell" is satisfied by every nonland card in every deck, so it excludes nothing and carries no information.
• An unreadable trigger is reported, not guessed. When a card's text names an event the vocabulary cannot spell, it is recorded as unknown rather than matched to the nearest thing that fits. A missing claim is better than a confident wrong one.

How it is checked

The engine is calibrated against 71 real Commander decks, every one of them fully resolved against the card corpus. Changes are measured on that set before and after — how many pairs formed, how many disappeared, and which ones — so a fix that quietly deletes real claims shows up as a number rather than as a feeling.

Individual pairs are hand-judged into a frozen panel: once a pair has a verdict, a change that flips it fails the build. Disagreements are quarantined with a cap, so a new one cannot be waved through and a fixed one has to be banked. The browser and the server paths are compared deck by deck and must produce byte-identical reports.

What it does not know

The card corpus is large but not complete, and a card the engine has never read forms no edges — the report says so rather than pretending the deck is fully understood. Edges are binary: the engine says two cards interact, not how much, which is why a token engine feeding a trigger forty times and a lone creature feeding it once look alike on the board. And the rules are written by people, so some claims are wrong.

If you find one, it is a bug with a name and a sentence attached — open an issue with the two card names and the line the report printed. The engine is open source.