How DeepBlue+ works (so far)
How DeepBlue+ works (so far)
TL;DR
DeepBlue+ is the strongest bot in the NSBA Buzzer card game — a **depth-limited, determinized
expectimax search** that plays the real game engine forward to value each in-game decision, plus a
search over the category pick that every earlier bot left greedy. It sits at the top of the Elo
ladder (2620) and wins ~82% of its games across the bot gauntlet. But it was tuned entirely against
other bots, and strong humans are now beating it consistently — which just exposed a real
limitation. This is how it's built and where it stands today.
The game, in one paragraph
Buzzer is a 24-question Science Bowl card game. You draft a ten-card deck of real NSBA players,
field four, and each question you (a) steer the category, (b) set each fielded card's posture — Goon
buzz (aggressive: buzz earlier, can steal it, but negs more and burns stamina), Safe (passive:
wait, convert more), or Normal — and (c) let the read resolve: every fielded card buzzes on its
own, the earliest to clear the cliff takes the tossup (+4) and a bonus (+10). A wrong buzz negs
(-4) and locks your team out. Winning the tossup lets you pick the next category. Stamina, fatigue
and rotation make it a management game, not just a stats game.
The lineage
DeepBlue+ isn't written from scratch — it's the top of a class hierarchy, each layer adding one
idea:
best, or decline.
fielding, keep/lock-in and rotation discipline. This is the *body*.
search.
What DeepBlue actually does
Every other bot picks its posture by a one-move-deep heuristic: score the table this question, take
the best-looking option. DeepBlue instead rolls the real engine forward and asks "which choice
leaves me in the best position a couple questions from now?"
For the posture decision each question:
by a quick 1-ply estimate (candidate_cap = 4). DECLINE is always in the running.
search_depth = 2 questions, determinizations = 5 times, re-seeding the engine's random draws each time (buzz
timing, conversion) and resampling the opponents' hidden bench cards. It uses common random
numbers across candidates so the comparison is low-variance.
the announced category before postures are set — matching what the live game and the offline
simulator do, so the search anticipates an opponent bringing an ace into the category it steers
to. (This is a recent fidelity fix.)
score gap and stamina left — not raw points. Pricing the leaf as "how likely am I to win from
here" is what made the search pay off; a raw-margin leaf was a wash.
resolve toward not spending the stamina.
At every OPPONENT decision node inside the rollout, DeepBlue assumes the opponent plays like the
disciplined MegaSanj proxy. (An online model that learns the specific opponent's tendencies exists
but ships OFF — it didn't beat the proxy in bot-vs-bot testing.)
What the "+" adds
The category pick is the single highest-leverage move in the game — whoever wins a tossup steers
the next question — and every prior AI picked greedily (name the category my field looks best in
right now). DeepBlue+ searches the pick the same way it searches postures: roll each candidate
category forward, price the leaf as P(win), take the best. Measured head-to-head, searching the
pick beats greedy-pick DeepBlue 64.8% (+-6.6, N=200) — the first clean positive result on this
engine.
Draft and fielding
DeepBlue+ does not search the draft — it inherits MegaSanj's prior-based draft (buy category
coverage, value the captain) and its fielding, keep and rotation logic. The search is purely an
*in-game* brain; the deck it's handed is chosen by heuristic.
Where it stands
pairing, on the exact live config and real card pool).
Against the bot field, this is the practical ceiling. A deep-learning value net, CFR/MCCFR, and
opponent-posture modeling were all tried and came back neutral-to-negative — the game is
deliberately variance-capped (24 questions is short, buzz luck dominates), so head-room over a
strong bot is only a point or three.
The limitation we just found
Multiple strong humans (Orca went 5-0, pine also beat it) are beating DeepBlue+ **consistently and
by a lot** — 184 to 91 on average, one game 190-44. The investigation ruled out the easy answers —
it's *not* the draft (the decks come out equal on paper, and across 27 of Orca's games his decks are
actually the same speed as the bots') and *not* bad luck. The real cause is structural, and it's
in the interface, not the search:
A bot can only set ONE card's posture per question. A human sets all four.
The human commit takes a full posture map — aggress your ace to win the buzz *and* pull your three
weak cards back to Safe, dodging negs and saving stamina, all in the same question. A bot policy
returns a single choice: field_contest_list puts "every fielded card at Normal except the one card
the coach boosted or pulled back." So a human does two things every round that a bot can only ever
do one of.
The numbers show it exactly: in his 27 games Orca sets a non-Normal posture on **67% of his fielded
cards** (20% aggressive + 47% Safe). A bot capped at one change per round maxes out around 25%.
DeepBlue+'s search is genuine, but it searches *inside* that handicap. A lone aggression leaves its
other three cards forced to Normal, where they can neg — so the search finds (correctly, for the
move set it has) that declining is usually best, and it played Normal on all 24 rounds of the 190-44
game. Getting out-tempo'd (first to buzz only 8 times of 24, the human 16) and having its best cards
locked out is the *symptom*; the one-posture ceiling is the *cause*.
Why the gauntlet never caught it: every bot shares the same one-posture handicap, so bot-vs-bot
is a fair fight — just a fair fight at a lower level than a human plays. I confirmed this by building
a bot that aggresses like a human; bound by the same one-Contest interface it did *worse* than
playing passive, losing 77% to DeepBlue+. The edge was never "aggression" — it's per-card posture
control that the bot API simply can't express.
What's next
The fix is to close the interface gap: let a bot policy commit a full per-card posture vector
like a human does, and extend DeepBlue's search from "one boost, or decline" to the best posture
*combination* (aggress the ace + Safe the liabilities). Only then can the search even consider the
line humans win with. After that, re-measure — against the bot field and against a human-calibrated
opponent — and see how much of the gap was the ceiling versus the search. That's the live thread.