How the Euchre AI Works: Determinized Monte-Carlo, Partner-Aware

The opponents on LK Forge Euchre have two problems a chess engine never faces: they can't see the other hands, and they have to play with a partner, not just against opponents. The Hard engine handles both with one classical idea — determinized Monte-Carlo.

Turn one hidden deal into many open ones

The engine takes what it has seen — its own hand, the up-card, everything played — and deals the unseen cards into a complete, plausible hand for everyone. That "determinized" deal is a normal open game it can play to the end for the whole table. It does this many times with different plausible deals and averages the results. The card with the best expected result for its team is the one it plays.

Partnership falls out of the scoring

Nothing tells the engine "cooperate with your partner." It emerges: because each sampled deal is played to the end for all four seats and scored by team points, the lines that survive the averaging are the partnership-correct ones — leading trump to draw the opponents', cashing aces before they can be trumped, and never trumping a trick the partner already wins. Good partnership play is simply what scores best when you play the whole hand out.

// determinized Monte-Carlo, scored by team result (schematic)
function chooseCard(view) {
  const total = new Map();
  for (let s = 0; s < SAMPLES; s++) {
    const deal = dealUnseen(view, rng);         // one plausible full deal
    for (const card of legalCards(view))
      total.set(card, (total.get(card) || 0) + teamScore(playout(deal, card)));
  }
  return maxBy(total);                           // best average for our side
}

That is the whole engine: turn a hidden deal into many open ones, play each out for the table, and average by team score. Curious how this method 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 Euchre AI decide its moves?

At the Hard level it runs a determinized Monte-Carlo engine: it deals the unseen cards many plausible ways, plays each imagined hand to the end, and picks the card with the best expected result for its team. It is a strong, honest opponent, though Euchre is a game where the deal matters a great deal. Beginner and Medium skip this sampling and instead follow simpler heuristics — playing loose cards or a solid partner-aware game — reserving the full search for Hard.

Does the Euchre AI play with its partner?

Yes — because each imagined deal is played out to the end for the whole table, the engine naturally scores partnership outcomes — it leads trump, cashes aces, and avoids trumping its own partner's winners, because those are the lines that come out best when averaged across sampled deals. No cooperation rule is coded in directly. Good partnership play simply falls out of scoring every sampled deal by team result rather than by one player's tricks alone.

How does the AI value the bowers?

The AI doesn't hard-code them — it deals and plays. In Euchre the right and left bowers are the two highest trumps, and because the engine plays every sampled deal to the end under the real rules (including the left bower changing suit), their power shows up in the scores rather than in a lookup table. That means the engine treats the bowers correctly by simulation alone, without ever being told explicitly which two cards are the strongest trumps.

Does the Euchre AI use a neural network?

No — the Euchre AI is classical determinized Monte-Carlo over the shipped rules engine — no machine-learned model, no server. Everything runs in your browser. Every decision comes from sampling plausible deals and playing them out under the real rules, not from a trained model.