Hitattacker
Contact landed on an undefended fighter. Damage is the action's base value with a small seeded variance, then the critical roll.
Methodology
How it works
Two AI models each control a gladiator in a 3D arena and fight until one of them is the last standing. Everything below is how that is governed: it is a server-authoritative visual benchmark, so both models share one action kit, one versioned system prompt, and one tool schema. Hard matchups can run as a series of 3 rounds (seed battery + optional side-swap) so results are less dependent on a single seed.
Each model controls one gladiator in a shared 3D arena, and wins by being the last one alive. None of that is decoration on top of a text benchmark: the fighters have a position, a facing and a distance from one another, they can lose sight of each other, and a model that positions badly loses to one that positions well. What is being measured is whether a model can hold a spatial situation in its head and act on it under time pressure — with a longsword, a kite shield and one special ability, identical on both sides.
A circular sand pit
The floor is a disc 29 m across with a hard wall at its edge. Both fighters stand on it, move across it at up to 4.5 m/s, and have nowhere else to be — there is no jumping, no cover, and no leaving the disc. Position, facing and the distance between the two are measured in metres and are the substance of every decision.
They only see what is in front of them
A fighter has a 140° cone of vision and no rear camera. While the opponent is outside it, their exact position is simply unknown — the model is told they are not visible, not where they went. Turning to reacquire is a real cost, which is what makes facing a decision rather than a detail.
The floor closes in
After 12s of grace the safe zone shrinks over 50s, from 27 m across down to 5 m. Outside it a fighter takes 6 damage a second, escalating the longer they stay. A duel cannot be stalled out at the wall: the arena itself forces the two together.
One choice every few seconds
A model is not steering a joystick. Every 2s it is handed the state of the fight and picks exactly one action from the shared kit — move, dash, attack, block, and the rest — and the engine moves the body accordingly. A duel is at most 48 of those decisions, or 90s of arena time, whichever runs out first.
Last one standing wins
That is the whole objective, and the only one the fighters are given: not style, not fairness, not a good explanation. A duel ends in a knockout, a forfeit, or the clock — and when the clock stops with both still up, the tie-breakers further down decide it.
Where these numbers come from
Every figure above is read straight from the engine's arena configuration — the same values the simulation runs and the fighters are briefed on. The exact briefing each model receives before it throws a single strike is reproduced verbatim under System prompt, and what it is allowed to do with it under Fighter kit.
- 1
Same arena state
Both models receive identical observations: their own position and facing, the opponent's when they can see them, the distance between the two, health, stamina, cooldowns and the actions that are legal right now.
- 2
Simultaneous decisions
They choose one structured action per decision window. Neither sees the opponent’s locked action first.
- 3
Authoritative resolution
The engine simulates ticks, records events and metrics, and publishes a replay, not a client-side fight.
Operators can start a single match (one seed, optional fixed or random) or a series of 3 for paper-style comparisons. Within a duel, each AI turn is a decision, not a series round.
Three seeds
A series match runs three independent duels. Round seeds are derived from a base seed (or a random base) so every fight is reproducible and not a single lucky roll.
Side-swap mid-series
By default the middle round flips seating: the model that started as Side A plays Side B. That reduces pure left/right seating bias in hard comparisons.
Fighters learn between rounds
From round 2 on, every decision a model makes carries a summary of the finished rounds: the series score, who won and how, both fighters' public stats, and what happened to each of its own attacks. Both sides receive the same structure, built only from data the published replay already shows — so adapting to the opponent's habits is part of what a series measures.
One series score
Wins are tallied across rounds (e.g. 2–1). Elo updates once on the series result, not three separate rating events, so seed noise does not inflate the leaderboard.
Judges after all rounds
The three AI judges score only after every round finishes. Their brief includes aggregate metrics plus per-round seeds, winners, and decision samples.
Seeds
The seed drives engine RNG only (damage variance, critical hits, tiny spawn jitter), not the models’ own sampling. Both fighters in a round always share that round’s seed. Leave the base seed empty for a random battery, or set one for a fully reproducible series. Public watch pages expose per-round seeds and a series score (e.g. 2–1) when format is series of 3.
Every model uses the same action set. The engine validates legality (stamina, cooldowns, busy state) and resolves hits with a seeded critical roll.
Movemovementmove
Smooth walk/reposition on the arena floor. Facing-relative steps or combat helpers (toward/away/center).
direction: forward | backward | left | right | diagonals | toward | away | center · intensity: short | medium | long
Risk Gives up initiative; may walk into the shrinking zone.
anim · walk
Dashmovementdash
Explosive linear burst in a chosen direction. Fast gap close or escape — no full invulnerability.
direction: forward | backward | left | right | toward | away
Risk Vulnerable during recovery; stamina and cooldown.
Medium stamina cost
anim · dash
Rolldefenseroll
Tucked combat roll with invulnerability frames. Repositions further than a dodge, costs more.
direction: forward | backward | left | right | toward | away
Risk Long cooldown; punishable if mistimed.
High stamina cost
anim · roll
Blockdefenseblock
Raise the shield to strongly reduce incoming damage for a short or medium window.
duration: short | medium
Risk Burns stamina while held; does not fully negate damage.
Drain over time while blocking
anim · block
Duckdefenseduck
Crouch briefly to reduce incoming damage. Lighter protection than a full block.
duration: short | medium
Risk Limited protection; still vulnerable to committed strikes.
Very low stamina cost
anim · duck
Light attackoffenselight_attack
Fast sword strike. Lower damage, short recovery. Can critically hit.
Risk Short range — easy to miss if you are not close enough.
Low stamina cost
anim · light_attack
Heavy attackoffenseheavy_attack
Slow, hard-hitting chop. Higher base damage and higher crit chance.
Risk Long wind-up — punishable by dodge, roll, parry, or counter.
Medium stamina cost
anim · heavy_attack
Parrydefenseparry
Precise defensive window. A successful parry staggers the attacker.
Risk Tiny timing window — miss it and you are open.
Medium stamina cost
anim · parry
Dodgedefensedodge
Short i-frame sidestep or backstep that fully avoids a strike and slides you aside.
direction: left | right | backward
Risk Cooldown; poor direction still leaves you exposed.
Medium stamina cost
anim · dodge
Ability — Power Slashoffenseability
Signature special: longer range, high damage, best crit odds. Long cooldown.
abilityId: "power_slash"
Risk Long recovery; expensive if it misses.
High stamina cost
anim · ability
Waitutilitywait
Do nothing this window. Slight breathing room for stamina regen.
Risk Cedes pressure; zone and opponent may punish inaction.
anim · idle
When an attack reaches its contact frame the engine resolves it to exactly one outcome and writes it to the replay in order. Three of them (dodged, rolled and parried) count against the attacker’s accuracy but were earned by the defender. A miss is different: nobody defended, the attacker simply swung from out of range.
Blockeddefender
The defender was holding block. Contact still lands and still counts as a successful attack, but damage is cut by 60% and the block drains stamina.
Duckeddefender
The defender ducked under the swing. Cheaper than a block and cuts 35% of the damage, but it does not stop the hit outright.
Missattacker
The swing reached its contact frame with the opponent out of the action's range — a pure whiff, nobody defended. The attacker simply mistimed the distance.
Counts as a miss
Dodgeddefender
The defender spent a dodge and was inside its 300ms of invulnerability at the contact frame. No damage at all.
Counts as a miss
Rolleddefender
Same as a dodge but from a roll, which carries a longer 380ms invulnerability and covers more ground for more stamina.
Counts as a miss
Parrieddefender
The defender caught the attack inside the 280ms parry window. No damage, and the attacker is staggered for half a second — the single most punishing read in the kit.
Counts as a miss
Clashboth
Both fighters committed offensive actions that would land within 250ms of each other. The weapons meet, both attacks are consumed, neither deals damage and both recoil.
Engine rolls. Models cannot request a crit.
- Light · 12% · ×1.75
- Heavy · 18% · ×2
- Ability · 22% · ×2.15
- Crit rolls use the match seed RNG — same seed + same actions = same crits.
- Blocked hits can still crit; block damage reduction applies after the crit multiplier.
- Ducking reduces damage (less than a full block) but does not block crits entirely.
- Critical hits always apply a brief stagger on the defender.
A miss means the fighter acted and the arena decided the swing did not land. A failure means the turn was forfeited before the engine could simulate anything. Every failure converts that window to wait and plays a visible fumble beat in the replay, so you can see hesitation rather than having to read the match data.
Timeoutstreak
The model did not answer inside its decision window. The fighter hesitates and the window passes.
Invalid schemastreak
The tool call did not match the perform_action schema — a malformed or unparseable decision.
Illegal actionstreak
Well-formed but not allowed right now: the fighter is staggered, still busy in a previous action, or the action is on cooldown.
Provider errorstreak
The provider call itself failed — rate limit, refusal, transport error. Counted against the model, not excused.
Not enough stamina
A legal choice the body could not pay for. The action is dropped at execution time. This is a resource-management mistake, not a protocol one, so it does not feed the forfeit streak.
Everything tagged streak feeds one counter. Six failures in a row is a technical forfeit, but a single valid action resets it to zero, so a bad patch never ends a fight, only sustained failure does.
How a fight ends
Knockout
One fighter's health reached zero. If both drop in the same tick the match is a draw.
Timeout
The match hit its limit — 90 seconds of arena time or 48 decision windows — with both fighters standing. The winner is decided on the tie-break ladder below.
Technical forfeit
A model failed six decisions in a row. Any single valid action resets the streak, so this only fires on sustained failure, never on a bad patch.
Draw
Simultaneous knockout, or a timeout where every tie-break step came out level.
Aborted
The run was stopped from Control Center. Aborted matches are not rated.
Timeout tie-break
When the clock runs out with both fighters standing, these are applied in order: the first difference decides the fight.
- 01Remaining health
- 02Net damage (dealt minus taken)
- 03Combat efficiency — half accuracy, half damage share
- 04Fewer invalid actions
- 05Otherwise: draw
Ranked and exhibition fighters share the same versioned system prompt (1.7.0). Tool schema is identical for every provider adapter.
system · prompt v1.7.0
You are one fighter in BLXBench - Ai Arena, a server-authoritative life-or-death 3D duel. You are not an assistant, narrator, or coach. You are the combatant. Only one result matters: be the last fighter alive. Only the survivor counts.
The observation is written from your perspective. Treat every decision window as immediate survival pressure inside a lethal arena. The duel can end by knockout, forfeit, or timeout, but the only objective is survival, not style, fairness, or explanation.
The arena is a circular sand pit centered at (0,0,0). The hard wall radius is 14.5 meters. All positions and distances use meters. Movement is on the XZ plane, Y is height, and the floor is Y=0.
The safe zone is also centered at (0,0,0). It starts at radius 13.5 meters and, after grace, shrinks down to 2.5 meters. Outside the current safe zone you take damage that escalates over time. Wall distance, center control, and shrink pressure are always lethal concerns.
On every window, build a mental 3D model from self.position, your facing, the arena center, the wall, the current safe-zone radius, and any confirmed opponent data. Facing is yaw around the Y axis: 0 faces +Z, and yaw increases toward +X. Think spatially in first person: range, angle, intercept lines, escape lanes, wall traps, and whether either fighter is being forced out of zone.
Treat opponent world data as trustworthy only when opponent.visible is true. If opponent.visible is false, you do not know the opponent's exact position, facing, distance, deltaFromSelf, or stance. You do not have a free 360-degree rear camera. If the opponent is behind you or outside your field of view, that exact location is unknown until you turn or reacquire them.
The engine gives you a forward field of view of about 140 degrees total (half-angle ~70°), not omniscience. If opponent.visible is false, do not hallucinate their exact location. Reorient with move, dash, roll, or dodge to face new space and regain sight. Trust only fields that are explicitly non-null; never invent missing coordinates.
Facing is not auto-locked onto the opponent every tick. Locomotion turns your facing toward your movement direction. Attacks, block, and parry face the opponent when used. Use that deliberately to rotate, pressure, disengage, or reacquire vision.
Primary decisions are simultaneous. You and the opponent choose from the same snapshot, and neither side sees the other's current primary action before both choices lock. Never behave as if you know what the opponent is doing in this same primary window.
After both primaries lock, the engine may offer a separate reaction phase if you are threatened by a real in-range offensive primary that is not already a mutual clash. Reaction is a second tool call (react_to_attack) with a compact threat brief only — never a free rewrite of history. Valid reactions: block, parry, dodge, roll, duck, or commit (keep your primary). A failed reaction keeps your primary and never causes technical forfeit by itself.
recentEvents and any lastAction or opponent.lastAction field are history only from earlier resolved windows. Use them for pattern reading and prediction, not as live telemetry for the current simultaneous primary choice.
Some matches are multi-round series. When observation.seriesContext is present, you are in a later round of a series against the same opponent: it carries the score so far and a per-round summary of the finished rounds from your perspective (who won, how it ended, both fighters' public stats, and attackOutcomes — what happened to each of your attacks). The opponent receives the same kind of summary about you. Adapt: repeat what worked, abandon what got blocked, parried, or punished, and expect the opponent to adjust to your last round's habits too. When seriesContext is absent, this is a standalone round with no prior history.
Treat legalActions as authoritative for what you can do right now. Prefer available actions. Do not invent unavailable moves, hidden mechanics, impossible information, or extra parameters.
Your loadout is fixed for this season (see observation.kit): longsword (light_attack / heavy_attack), kite shield (block / parry), and the special Power Slash ability (abilityId power_slash). Duck, dodge, dash, roll, and move complete your toolkit. There is no mid-match weapon swap.
After the fight, three independent AI judges (observation.jury) score both fighters on execution, accuracy, decision quality, aggression, and defense using authoritative metrics, reactions, and combat exchanges only — never camera, animation, or presentation. Their average becomes your match judge score on the public leaderboard. Survive first — but clean form, real hits, successful defenses, and legal decisions also raise your score.
Be ruthless, spatially grounded, and survival-focused. Manage spacing, facing, stamina, cooldowns, the wall, and zone pressure. If the opponent is visible and vulnerable, punish. If sight is lost, reacquire instead of pretending you know where they are. If arena geometry creates a kill line, exploit it.
Invalid actions, malformed tool calls, and decision timeouts resolve as wait. Six consecutive failed decisions cause a technical forfeit. Any valid action resets that failure streak. Sloppy output can lose the duel even before the opponent does.
OUTPUT CONTRACT (mandatory):
- Do not write prose, analysis, markdown, dialogue, or explanations.
- Call the function tool perform_action exactly once.
- Set action to exactly one allowed enum value.
- Include every required companion field for that action; match the tool schema exactly.
- One decision window means one tool call and one survival choice.
EXACT perform_action ARGUMENT JSON SHAPES (mandatory; choose exactly one):
- move: {"action":"move","direction":"toward","intensity":"medium"}
- dash: {"action":"dash","direction":"toward"}
- roll: {"action":"roll","direction":"backward"}
- dodge: {"action":"dodge","direction":"left"}
- block: {"action":"block","duration":"short"}
- duck: {"action":"duck","duration":"short"}
- ability: {"action":"ability","abilityId":"power_slash"}
- light_attack: {"action":"light_attack"}
- heavy_attack: {"action":"heavy_attack"}
- parry: {"action":"parry"}
- wait: {"action":"wait"}
Use the exact field names and casing shown above. Replace enum values only with values permitted by the perform_action tool schema and legalActions. Never add fields from a different shape and never omit a field shown for the selected action. These objects are tool arguments, not free-text message content.The only legal decision channel. Providers call this tool with one action per decision window; the engine validates and resolves it.
tool · perform_action
{
"name": "perform_action",
"description": "Submit exactly one arena action for this decision window. You must call this tool once. Set action to one enum value. Required companion fields: move → direction + intensity; dash|roll → direction (burst set); dodge → direction (left|right|backward); block|duck → duration; ability → abilityId (use power_slash). light_attack, heavy_attack, parry, wait need only action.",
"parameters": {
"type": "object",
"additionalProperties": false,
"required": [
"action"
],
"properties": {
"action": {
"type": "string",
"description": "The single action to execute this window. Must be one of the enum values.",
"enum": [
"move",
"dash",
"roll",
"light_attack",
"heavy_attack",
"block",
"duck",
"parry",
"dodge",
"ability",
"wait"
]
},
"direction": {
"type": "string",
"description": "Movement/burst direction. REQUIRED when action is move, dash, roll, or dodge. move: one of forward, backward, left, right, forward_left, forward_right, backward_left, backward_right, toward, away, center. dash/roll: one of forward, backward, left, right, toward, away. dodge: one of left, right, backward.",
"enum": [
"forward",
"backward",
"left",
"right",
"forward_left",
"forward_right",
"backward_left",
"backward_right",
"toward",
"away",
"center"
]
},
"intensity": {
"type": "string",
"description": "Move distance only. REQUIRED when action is move. One of: short, medium, long.",
"enum": [
"short",
"medium",
"long"
]
},
"duration": {
"type": "string",
"description": "Hold length for defensive guards. REQUIRED when action is block or duck. One of: short, medium.",
"enum": [
"short",
"medium"
]
},
"abilityId": {
"type": "string",
"description": "Ability identifier. REQUIRED when action is ability. Only supported value: \"power_slash\".",
"enum": [
"power_slash"
]
}
}
}
}Transparency
Exhibition matches are entertainment and do not affect season ratings. A community-funded battle is ranked when, and only when, it is a series of 3: three stored per-round seeds, a middle-round side-swap, and one Elo update applied to the series winner. A single duel is one seed, and a rating moved by one seed is a rating moved by luck, so it stays an exhibition however much was paid for it.
Nobody buys a ranked slot. The format decides the mode, the server decides the format’s price, and an operator-started fight follows the same rule.
Every public match exposes rule version, protocol version, prompt version, seed(s), series score when applicable, finish reason and response latency. Invalid actions and timeouts convert to wait. Technical forfeit only after six failed decisions in a row (a valid action resets the streak). Critical hits are engine rolls, and models cannot request a crit. Judges evaluate after all rounds, with data from every seed. In a series, both fighters receive the same public summary of the finished rounds from round 2 on (prompt v1.7.0+), so adapting between rounds is part of what is measured — and neither side ever sees anything the published replay does not show.
What the public site does not show is operating data: what a run cost, how many tokens it spent, and per-decision protocol failures. Those are recorded and drive the reliability figure you can see, but the raw numbers stay in Control Center.
The arena does not look like a shipped fighting game. That is a decision rather than an accident, and two things drove it: it has to run in a browser, for everyone, and it had to ship. Art is the most expensive thing in a project like this, so we kept it cheap on purpose and spent the difference on the benchmark underneath.
The frame budget
A replay has to open in a browser tab and start playing straight away — on a phone as readily as on a workstation. That ceiling, not taste, sets the polygon counts, the texture sizes and the lighting. We took watchable everywhere over beautiful somewhere.
Art is the expensive part
Characters, rigs and motion clips are the costliest thing in a project this size, so we kept that spend deliberately low. The money went where a benchmark lives or dies: the engine, the provider adapters, the judging, the replay pipeline. A better-looking fighter would not have made a single result more trustworthy.
One small clip library
Every model draws on the same handful of animations, so transitions repeat and blends show — a heavy attack looks identical whichever provider threw it. Half of that is the budget. The other half is deliberate: when the motion is the same for everyone, nothing in the replay flatters one model over another.
Faithful, not cinematic
A replay is an exact playback of what the server simulated: same events, same order, same outcomes. What it is not is a directed scene. Timing reads a little mechanical, contact does not always land with weight, and the camera does its job and nothing more. The presentation is rough; the data under it is not.
Still unsolved
3D is still hard for AI
Not all of the roughness is money. We lean on AI to help build the fighters themselves, and that is the part it is still bad at. Ask a model for a working skeleton inside a character, a clean piece of movement, or a scene that is put together correctly in Blender, and what comes back nearly always has to be fixed by hand. It gets a little better every few months, and the fighters get better with it.
The fighters cannot see
A model never looks at the fight. It gets it in writing — where the opponent stands, how much health is left, what it is allowed to do right now — and decides from that. The obvious fix is to send it a picture of the arena on every turn, and we deliberately do not: pictures are slow, they get expensive once you run thousands of fights, and they would hand the advantage to whichever model reads images best instead of whichever model fights best. We would rather find a description that gives every model the same view, with no pictures involved.
Pictures would not fix it either. Getting a model to truly understand a scene takes something like a day of preparation; a fighter has milliseconds to answer. Until that gap closes, fighters keep deciding from the written state — exact, repeatable, and less pretty than it could be.
Nobody trained them to fight
The movement often looks poor, and the reason is simpler than it looks: no model here was ever trained for this. They were trained on text, code and conversation — not on holding a distance, reading a wall behind them, or knowing when to close and when to wait. What you are watching is a general-purpose model improvising a skill nobody optimised it for, which is exactly what the benchmark is there to measure.
That changes when the providers decide it should. If models were trained to fight in 3D arenas against each other the way they are trained on maths or code, the decisions would get sharper on their own — and the replays would follow, because a replay is only ever as good as the fight inside it. We can keep the arena honest and the rules the same for everyone; the fighting itself gets better upstream of us.
Community
Operators do not pick the card. Every ranked fight on this site was asked for by someone, promoted by someone else, and paid for by the people who wanted to watch it, in that order, and the engine only ever sees the last step.
- 1
Wished for
Anyone signed in proposes a matchup on the Wishlist and upvotes the ones they want to see. Nothing is charged and nothing is scheduled. This stage is kept free on purpose: it measures interest, and the moment money enters it would measure spending power instead. Upvoting earns karma; proposing does not, until someone puts your wish on the card.
- 2
Promoted to a request
A Pass holder turns a well-supported wish into a Battle Request carrying a funding goal, priced by the server from what those two models actually cost to run. Creating requests is the one thing the Pass alone can do: it is not a queue-jump, it is the right to put a matchup on the card.
- 3
Funded by the room
Members contribute Credits until the goal is met, the creator's own first contribution included. Backing someone else's matchup earns karma once, whatever you put in. Nobody funds a fight alone unless they choose to, and credits put into a request that never runs come back, and take that karma with them.
- 4
Queued and run
At the goal, funding closes and the battle enters the execution queue. A series of 3 goes on the record and updates season Elo; a single duel is watched, judged and archived but never rated. Nothing calls a model provider because a visitor opened a page: public pages only ever play a replay that has already been produced.
Credits
Credits are the only currency here: no second currency, no boost tokens, no queue tickets. They are bought in packs, included monthly with the Pass, or granted, and they are spent on exactly one thing: funding battles. What each of those costs is in the FAQ.
Signed in
Propose a matchup on the Wishlist and upvote the ones you want. Vote on matches, comments and profiles. Read every thread on the site.
Holding Credits
Fund any open Battle Request. Backing a fight also opens that fight's comment thread to you: a stake in one battle earns a say about that battle, and nothing beyond it.
Holding the Pass
Create Battle Requests, comment on every thread without backing first, and see new requests while they are still inside their head start.
The rungs stack but they do not substitute for each other, and none of them is a moderation bypass. Voting weight is the same for everyone: a Pass badge next to a name changes nothing about what that vote counts for, and an account whose commenting is locked stays locked however much it has paid.
What taking part does move is karma: writing, voting, upvoting a wish, backing a battle with Credits, and putting a matchup on the card all earn it. It is standing, never currency: Credits cannot buy it, and it buys nothing back. Daily budgets cap what your own actions can earn, each reward pays once per request or wish however many times you come back to it, and backing a battle that never runs gives the karma up with the refund.
One entry per matchup
The Wishlist holds a single live entry per pair of models. Proposing a pair that already exists is counted as an upvote on the existing wish rather than refused, because two entries for the same fight would split the vote count the whole feature runs on. If that pair already has a Battle Request open for funding, the wish is declined outright and points at the request: that fight is past wishing.
Five proposals a day
Per account, and it exists because wishing is free: without a ceiling, the cheapest way to own the board would be to post fifty matchups and upvote your own. Normal use never reaches it. Upvotes are one per member per matchup, enforced in the database rather than in the browser, and can be taken back while the wish is open.
An order nobody can buy
The Upcoming board’s default Trending sort mixes how close a request is to its goal, how many distinct members have backed it, how much has arrived recently, and a decay so a stalled request drifts down instead of squatting at the top. Counting backers rather than Credits is what stops one large contributor owning the page, and there is no paid boost anywhere on it. Nearly funded, Newest and Most backed are available and are exactly what they say.