How the Bridge AI Works: Determinized Monte-Carlo and Make-Probability

The players around the table on LK Forge Bridge — your partner North, and opponents East and West — each face the game's defining difficulty: half the cards are hidden. Even as declarer, once dummy is down you see 26 cards and must place the other 26 between two unseen hands. The engine handles this with determinized Monte-Carlo, and the same machinery produces the make-probability shown on screen.

Guess the hidden hands — many ways

The engine takes what it legitimately knows — its own cards, the dummy, the auction, every card played — and deals the 26 unseen cards into a complete, plausible layout for the two hidden hands. That single "determinized" deal is now a fully open bridge hand it can play out to all thirteen tricks. It repeats this many times with different plausible deals, plays each to the end, and scores the options. The card that does best on average across the sampled deals is the one it plays.

// determinized Monte-Carlo + make-probability (schematic)
function analyse(view) {
  const total = new Map(); let made = 0;
  for (let s = 0; s < SAMPLES; s++) {
    const deal = dealUnseen(view, rng);          // a plausible split of the 26
    const r = playToThirteen(deal);              // full open-hand play
    if (r.contractMakes) made++;                  // tally for make-probability
    for (const card of legalCards(view))
      total.set(card, (total.get(card) || 0) + r.value[card]);
  }
  return { bestCard: bestBy(total), makeProb: made / SAMPLES };
}

Why it plays honest bridge

Because it never sees the real hidden hands, the engine can't fall into the classic computer-bridge cheat of playing perfectly against cards it shouldn't know. It plays against the range of hands consistent with the auction and the cards so far — finessing when the sampled deals say a finesse pays, ducking when they say duck. And the make-probability is simply honesty made visible: the fraction of those imagined deals in which the contract came home.

That is the whole engine: guess the two hidden hands many ways, play each deal to thirteen tricks, average, and read the make-probability straight off the tally. Curious how sampling-based card AI holds up under measurement? Read our study of a determinized-MC card engine, or why our games are search, not chatbots, in Real Game AI, Not a Chatbot.

FAQ

How does the Bridge AI choose its cards?

The Bridge AI runs a determinized Monte-Carlo engine: it deals the unseen hands many plausible ways, plays each imagined deal out to thirteen tricks, and scores its options. The card that does best across those sampled deals is the one it plays — for declarer and for the defence. The whole search runs client-side in your browser, so nothing is sent to a server.

What is the make-probability the game shows?

The make-probability readout is the engine's honest estimate of how often the current contract makes, taken straight from the Monte-Carlo run: of all the plausible deals it sampled and played out, the share in which the contract succeeds. It updates as cards appear and the range of possible hidden hands narrows. It is not a separate calculation — it is the tally of the same sampled deals the engine already plays out to choose a card.

Does the AI cheat by looking at the hidden hands?

No — the AI only knows what a player would: its own hand, the dummy once it is exposed, and every card played. The unseen cards are guessed — sampled many ways consistent with the bidding and play — so the engine plays against a range of hands rather than peeking at the actual ones. That mirrors how a human declarer or defender has to reason about the cards they cannot see.

Does the Bridge AI use a neural network?

No — the Bridge AI is a classical determinized Monte-Carlo search over the shipped rules engine — no machine-learned model and no server. Its strength comes from how many deals it samples and plays out, not from training. Everything runs in your browser.