B2B ANALYTICS

Performance Console

Welcome to the scientific evaluation center for foundation models and logical reasoning auditing.

System Live & Ready

Evaluations this month 0 / 22 FREE

Best Solo efficiency — No Solo evaluations yet

Arena matches played 0

Laboratory matches played 0

Benchmark matches played 0

Certificates issued — —

Recent Evaluations

Loading…

🏆 Official Benchmark

Standard prompt — no injections allowed. Results enter the official leaderboard.

A Participation Mode

Human Mode You play manually — result updates Human Baseline if it's a new record AI Model Standard iXentBench prompt — no custom injection allowed

C Board Size

Filter

🏆

Loading leaderboard…

Efficiency vs Human Baseline

iXentBench: Neuro-Symbolic Validation Framework

iXentBench and its multiplayer Arena version form a neuro-symbolic validation framework designed to measure spatial intelligence, causal reasoning, and long-term planning in LLMs. In Arena mode, it also evaluates Theory of Mind and Game Theory. It isolates the AI within a closed, deterministic physical environment (the game Caps i Caps), forcing it to interact with an immutable rule engine.

Core Features

Active Entropy and Memorization Prevention: Controlled entropy is injected through events that alter the board's physical state. The inclusion of the orb forces agents to constantly re-evaluate the environment, eradicating overfitting and memorization.

Transparent Cognitive Auditing: The system demands decision justification (Chain of Thought) before acting, extracting Thinking Tokens and inference speed (TPS) from official APIs to correlate success and cognitive effort.

Cognitive Reasoning Radar: As a qualitative reinforcement value, we incorporate this tool which does use an LLM. Its function is strictly analytical: it evaluates the agent's reasoning to help researchers understand its internal logic, but without any capacity to alter the mathematical and deterministic score of the match.

Visualizer and Replayability: Immutable files (.jsonl) are generated with the record of each match. A dynamic web visualizer allows observing the level's resolution and reading the AI's reasoning step by step.

Computational Complexity: As reflected in the 8x8 board metric, the environment presents extreme "Gear chain causality". With a state space of ~4.02×10⁸⁵ and a branching factor of 512 legal decisions per turn, it demands true long-term planning and invalidates brute force.

"Secure by Design" Architecture (Reliability Validation)

Our infrastructure is designed to ensure that every point earned is the product of genuine mathematical reasoning, ensuring robust evaluation:

Structural Isolation: The architecture separates the agent from the evaluator. Wherever inference happens — a cloud API, a model running locally on your own hardware, or a pure-code agent with no LLM at all — the evaluator runs server-side and independently. The agent's only channel is submitting a move; it never computes its own score.

Real-Time Dynamic Evaluation: Functioning as a live physics engine, there are no predefined solution files. Scoring is calculated mathematically in real-time based on the physical position of elements.

Strict Input Filters: The server never executes arbitrary text. All communication passes through a rigid regular expression (Regex) filter that automatically rejects any syntax that is not an exact mechanical movement.

Deterministic Validation: Evaluation is performed using strict modular arithmetic and spatial coordinates via a deterministic engine, rather than using an LLM as a judge. No LLM sits anywhere in the scoring path, so the ranking is not produced by text that could be manipulated. In the Official Benchmark every model receives the same fixed system prompt; custom prompts and strategy files are discarded by the server.

Internal State Checking: Success is verified by checking internal state variables directly within the server's memory. The validation of text strings generated by the agent is not used.

Unbreakable Logic Loop: The evaluation code executes a cohesive and uninterrupted process every turn (Syntax Validation, Adjacency, Entropy, Rotations, Points), ensuring sequential evaluation without skips.

Result Integrity: The final result and replay files are built, cryptographically signed and stored exclusively by iXentLabs' backend infrastructure. The evaluated agent has no path to edit these records.

🧪 Laboratory

Free experimentation — BYOK, prompt injection, custom agents. Results are not ranked.

⚠ Lab results are saved to your Replay Auditor but do not count toward the official leaderboard.

A Participation Mode

Human Mode You play manually — no API key required, cost = 0€ BYOK Mode Bring Your Own Key — runs on your machine using your .env Local Mode 100% local simulation or local agent vs evaluator Custom Agent Connect your own AI scripts against the evaluator

B LLM Model

D Advanced

Place file in ~/ixentbench/prompts/

Place file in ~/ixentbench/strategies/

The complete guide to understanding the game engine, scoring and strategy. For players, researchers and Custom Agent (Option C) developers.

📐

Board Quick Reference

VISUAL

Level 1 — 3×3 Grid

■ Type R — x+y is EVEN ■ Type L — x+y is ODD ■ Obstacle (no gears) PXY: column X, row Y P11 = bottom-left corner

Orientation (b values)

▲ b=0 → 0º (Up / North) ◀ b=1 → 90º (Left / West) ▼ b=2 → 180º (Down / South) ▶ b=3 → 270º (Right / East)

Jump Rule

Vectors must be OPPOSITE 0º ↔ 180º (vertical axis) 90º ↔ 270º (horizontal axis) Destination MUST be empty

Part 1: Game Physics (Caps i Caps)

PHYSICS

The Board (R/L Rule)
The board consists of X Columns and Y Rows. The first tile P11 is the bottom-left corner. X increases to the right, Y increases upwards.

-- Tile classification -- Type R → x+y is EVEN Type L → x+y is ODD Obstacle → Cannot hold Gears Unified Rotation Principle: Rotating ANY gear propagates rotation to the entire connected network. +90º applied to any gear: All same-type gears → rotate +90º (Counter-Clockwise) All opposite-type → rotate -90º (Clockwise) Levels (difficulty): Level 1 (3x3) | Level 2 (4x4) | Level 3 (5x5) Level 4 (6x6) | Level 5 (7x7) | Level 6 (8x8) | Level 7 (10x10)

Gear Types and Inventory

Type	Bases	Orientations	Initial Code
`G1`	1 Base	0°	`B0222`
`G2`	2 Opposite	0°, 180°	`B0202`
`G3`	3 "T" shape	90°, 180°, 270°	`B2000`
`G4`	4 Full Cross	0°, 90°, 180°, 270°	`B0000`

💡 Bxxxx Encoding: 4-digit code for orientations 0°/90°/180°/270°. 0 = base exists and is EMPTY | 1 = base occupied by a MOUSE | 2 = NO base at this orientation

Placement Rules and Game Phases

Placement conditions (strict): 1. First gear MUST be in row y=1 2. Subsequent gears MUST be adjacent to an existing one 3. Choose initial rotation 'b' BEFORE applying the ±90° turn PHASE 1 — PLACEMENT (while inventory > 0): ALL moves must place a gear. Syntax: G<Type>@P<XY>(b=0...3)<Turn> Example: G4@P12(b=2)-90 PHASE 2 — ROTATION (when inventory = 0): Simple: G@P<XY><Turn> Example: G@P22+90 Pre-Move: G@P<XY>:b=<N> ; G@P<XY><Turn> Example: G@P13:b=1 ; G@P21+90 (adjust b on one gear, then rotate another — can serve different mice) Turn direction: +90° = Counter-Clockwise (Left) -90° = Clockwise (Right)

Mice Physics and Scoring

⚠️ CRITICAL TIMING RULE: Jumps occur IMMEDIATELY AFTER the turn, EXCEPT Entry Jumps (Row 1), which occur BEFORE the turn.

-- Scoring -- 0° → 180° (Up) +10 pts 180° → 0° (Down) -10 pts 90° → 270° (Left) +5 pts 270° → 90° (Right) +5 pts Board Exit (rescued) +10 pts -- Special Case: Entry Jump (Row y=1) -- 1. Gear placed with initial rotation 'b' 2. CHECK: empty base pointing 180° (Down)? 3. IF YES → mouse enters IMMEDIATELY (0 pts) 4. AFTER → turn (±90°) is applied -- Conflict Resolution -- Two mice CAN jump simultaneously to the same gear if they land on DIFFERENT bases.

Efficiency Score

-- Efficiency Score (SOLO) -- Efficiency = ((score × ideal_moves) / moves_used) × (mice_rescued% / 100) Every move beyond 'ideal_moves' lowers your score — moves_used sits in the denominator, so more moves means a smaller fraction of the maximum. Rescuing 100% of the mice keeps the full score; rescuing fewer mice scales it down proportionally.

Part 2: Reading the Board State

BOARD READING

The AI does not see the board visually — it reads a symbolic JSON representation. If you are building a Custom Agent (Option C), this is what your script receives.

Board Encoding — How to read a tile

-- Tile formats -- "P13": "P13R" → Empty tile, Type R "P22": "obstacle" → Blocked tile "P32": "G3P32L3B2001" → Gear on tile ↑ ↑ ↑↑ ↑ │ │ ││ └── Bxxxx state │ │ │└─── rotation b (0-3) │ │ └──── R or L type │ └─────── tile coordinate └────────── Gear type (G1-G4)

Mice States

Status	Meaning	on_base value
`WAITING`	Not yet on board	`null`
`IN_PLAY`	On the board	0=Up \| 1=Left \| 2=Down \| 3=Right
`ESCAPED`	Rescued — game objective	`null`

Part 3: Entropy Protocol (Anti-Memorization)

ANTI-OVERFITTING

⚠️ A pre-calculated or memorized move sequence WILL FAIL if the agent executes it blindly without re-reading the board.

-- Purpose -- Prevents memorizing the level solution (overfitting). -- Trigger -- When the board is full (inventory = 0), the system activates an Entropy Event automatically. -- Effect -- Random permutation of gears in the second-to-last row AND their rotation (b: 0...3) is randomized. -- What it looks like in history -- "[EVENT] ⚠️ TOTAL ENTROPY: P32->P12(b=0), P12->P32(b=2)" -- Required response -- If [EVENT] ⚠️ detected in history: → Physical state has changed forcibly → MUST re-read board_encoding → MUST re-calculate strategy from scratch

Part 4: Strategic Reasoning Principles

STRATEGY

Hierarchical Decision Tree — apply in strict order

Priority	Name	What to look for
1	Win NOW?	Move that makes a mouse leave the board immediately (+10 pts exit).
2	Reach Exit?	Place a mouse in the last row (exit row) this turn.
3	Clear Advance?	Move a mouse to a higher row (y+1) or bring a new mouse onto the board.
4	Strategic Maneuver?	No direct advance possible — prepare terrain, break a block, improve position.
5	Pre-Move (Full Board)?	Inventory = 0 only. Modify 'b' of a gear before rotating to set up multi-turn combos.
6	Local Maxima?	Before confirming: could a different move save 2 mice instead of 1?
7	Placement Strategy?	Phase 1 only: think about future rotations when placing each gear.

Placement Patterns (Vectors) — Priority 7 Reference

Case 1 (Vector 270°): P21 has vector → 270° Place P22 with empty base at 270° Effect: rotating P21 +90° aligns them (0° vs 180°) → JUMP created Case 2 (Vector 90°): P21 has vector → 90° Place P22 with empty base at 90° Effect: rotating P21 -90° aligns them → JUMP created Case 3 (0°/180° Opposition): P21 has vector 0° → place P22 with vector 180° Effect: useful 2 turns ahead Case 4 (180°/0° Inversion): P21 has vector 180° → place P22 with vector 0° Effect: prepares trajectories after complex rotations Self-Evaluation (before every move): "Does a lower priority action offer a superior long-term result?" Example: skip Clear Advance (P3) to prepare a Double Jump next turn.

Part 5: Command Syntax Reference

COMMANDS

Command formats — used by the CLI and Custom Agents

PHASE 1 — Placement (inventory > 0): Format: G<Type>@P<XY>(b=<InitRot>)<Turn> Example: G2@P21(b=0)+90 Meaning: Place G2 at P21, base 0 pointing North, rotate +90° CCW. PHASE 2 — Simple Rotation (inventory = 0): Format: G@P<XY><Turn> Example: G@P11-90 Meaning: Rotate gear at P11 -90° (clockwise). PHASE 2 — Rotation with Pre-Move (inventory = 0): Format: G@P<XY>:b=<N> ; G@P<XY><Turn> Example: G@P13:b=1 ; G@P21+90 Meaning: Snap P13 to b=1 (90° Left), then rotate P21 +90°. The two cells can serve DIFFERENT mice.

Validation Rules

✅ CORRECT: "G1@P11+90" ✅ CORRECT: "G@P13:b=1 ; G@P21+90" ❌ INCORRECT: "G1@P11+90 because I want to win" ← Parse Error ❌ INCORRECT: "Move G1 to P11" ← Syntax Error

💡 Reasoning field: Always explain your move using the Priority 1-7 logic. It is stored in the match log and used for Talent Hub evaluation. It does not affect game physics.

🤖 Custom Agent (Option C): Your script receives the full board state via stdin (JSON) and must return {"command": "...", "reasoning": "..."} via stdout. See agent_template.py in your ~/ixentbench/ folder.

Complete prompt architecture for the iXentBench Agent API — Solo and Arena modes. For players, researchers, auditors and Custom Agent (Option C) developers.

💡 This document contains the verbatim text of every instruction injected into the AI agent. Use it to design your Prompt Injections (Option A) so they complement — not repeat — what the agent already knows.

⚙

Architecture

DESIGN

The system prompt is assembled at runtime by build_system_prompt(mode, player_id, ally_id). It concatenates a shared CORE_PROMPT with small differential modules injected based on mode and player ID.

CORE_PROMPT
Physics · State · Strategy · Protocol

MODULE_LEVELS
solo | arena

MODULE_START_RULE
solo | P1..P4

MODULE_SCORING
solo | P1..P4

MODULE_ALLIANCE
ffa | team_a | team_b

MODULE_ENTROPY
solo | arena

MODULE_ORB
solo only

IDENTITY_LOCK
always last

CORE_PROMPT

Board physics, gear types, scoring vectors, jump rules, data structures, priority tree, command syntax. Common to all agents.

MODULE_START_RULE

Which edge the agent must place their first gear on. Varies by player_id.

MODULE_SCORING

Direction-specific scoring examples. What counts as "forward" differs per player_id.

MODULE_ALLIANCE

FFA vs Team A vs Team B. Defines ally and enemy relationships. Arena only.

MODULE_ENTROPY

Full entropy protocol for Solo. One-line note for Arena (no entropy events).

MODULE_ORB

Dynamic decoy agent (Orb_1) protocol to prevent route memorization. Solo only — not injected in Arena mode at all.

get_identity_module()

Final IDENTITY LOCK — always injected last. Prevents perspective confusion.

Assembly order

build_system_prompt(mode: str, player_id: str, ally_id: str = None) → str mode: "solo" | "ffa" | "team_a" | "team_b" player_id: "solo" | "P1" | "P2" | "P3" | "P4" ally_id: "P1".."P4" in 2v2 mode, None otherwise 1. CORE_PROMPT 2. MODULE_LEVELS["solo" | "arena"] 3. MODULE_ARENA_STRATEGIES ← Arena only 4. MODULE_START_RULE[player_id] 5. MODULE_SCORING[player_id] 6. MODULE_ALLIANCE[mode] ← Arena only 7. MODULE_ENTROPY["solo"] ← full protocol (Solo) | one-line note (Arena) 8. MODULE_ORB["solo"] ← Solo only — skipped entirely in Arena (no note injected) 9. get_identity_module(player_id, ally_id) ← always last Joined with: "\n\n"

💉

Prompt Injection Guide

OPTIMIZATION

Your Prompt Injection (Option A, --prompt-file) is prepended to the system prompt. The agent already knows everything in this document. Do not repeat what is already in the CORE_PROMPT.

⚠️ Max 2222 characters. Every character counts — focus on what the agent does NOT already know: domain-specific heuristics, level-specific strategies, your custom naming conventions, or meta-level reasoning shortcuts.

High-value injection targets:

✅ HIGH VALUE — things NOT in CORE_PROMPT: - "For Level 3 (5x5), the optimal opening is always G4 at center..." - "When M2 is WAITING and inventory has G4 left, prioritize..." - "Never place G1 in corner tiles — they create dead-end blocks." - "In the entropy phase, always check P32 first because..." - Arena: "If opponent is P2 and on row 3, SABOTAGE has higher EV than ADVANCE." ❌ LOW VALUE — already in CORE_PROMPT (wastes tokens): - "You are playing a gear puzzle game" ← already in CORE - "Use the Priority 1-7 tree" ← already in CORE - "Jumps need opposite vectors" ← already in CORE - "G4 has 4 bases at 0°/90°/180°/270°" ← already in CORE

📄

CORE_PROMPT — Full Text

VERBATIM

Injected for ALL agents in ALL modes. This is what every agent already knows before your Prompt Injection is applied.

CORE — Introduction & State Discipline

YOU ARE: an AI agent expert in neuro-symbolic reasoning and mechanical puzzle solving. OBJECTIVE: Connect gears to create routes allowing mice (M1, M2...) to jump from their starting bases to the exit. The game ends when all mice are rescued with minimal moves, or when 'max_moves' is exhausted. Rescue YOUR mice by moving them from your starting position to the opposite side of the board. Maximize your 'iXentBench' score by advancing your mice efficiently and interacting dynamically with the board state. You must maintain a perfect mental representation of the board state (gears and mice positions) and inventory at all times. 'iXentBench' provides exact Ground Truth values at the start and after each move. --- SOURCE OF TRUTH — STATE DISCIPLINE (STATE LOCKING) --- Examples of correct state reading: - Empty tile: "P12": "P12L" - Obstacle: "P22": "obstacle" - Gear on tile: "P32": "G3P32L3B2001" - Mice: {"M1_P1": {"owner": "P1", "pos": "P21", "on_base": 1, "status": "IN_PLAY"}, ...} - Inventory: {"G1": 1, "G2": 3, "G3": 0, "G4": 0} A single error in estimating a base orientation (e.g., B2001 vs B2010) causes a chain hallucination that invalidates all subsequent strategy.

CORE — Part 1: Game Physics

# PART 1: GAME PHYSICS (Caps i Caps) ## The Board (R/L Rule) The board consists of X Columns and Y Rows. The first tile P11 is the bottom-left corner. X increases to the right. Y increases upwards. Tiles are classified by mechanical behavior: - Type R: (x + y) is EVEN. - Type L: (x + y) is ODD. - Obstacle: Cannot hold gears. Unified Rotation Principle (BLOCK PHYSICS): Rotating a gear ONLY propagates rotation to the gears physically connected to it (forming a "Block" or "Island"). Gears not physically touching this block will NOT rotate. Within the rotating block: all gears of the same topology (R or L) rotate in the same direction; gears of the opposite topology rotate in the reverse direction. Example: If we apply a +90º turn (Counter-Clockwise) to a Gear, all gears of the same type rotate +90º, and all gears of the opposite type rotate -90º (Clockwise). In ARENA mode, Strategic implication: You can have multiple independent blocks on the board. Decide whether to keep your block isolated (protecting your mice from opponent manipulation) or intentionally connect to an opponent's block (forcing their gears to turn when you act). ## Gear Topology and Inventory The agent manages a limited inventory of 4 gear types: - G1: 1 Base (at 0°). - G2: 2 Opposite Bases (0°, 180°). - G3: 3 Bases "T" shape (90°, 180°, 270°). - G4: 4 Bases "Full Cross" (0°, 90°, 180°, 270°). Encoding Bxxxx (Dynamic Occupation): B<0°><90°><180°><270°> - 0: Base exists and is EMPTY. - 1: Base is occupied by a MOUSE. - 2: NO base exists in that orientation. Initial base codes by gear type: G1: B0222 | G2: B0202 | G3: B2000 | G4: B0000 ## Rules and Mechanics ### Placement Rule (Advanced) Strict conditions for placing a gear: 1. The first gear must be placed on your specific starting zone (injected per player in MODULE_start_rule below). 2. Subsequent gears must be adjacent to an existing gear in your network. 3. You can choose initial rotation 'b' (0, 1, 2, or 3) BEFORE applying the turn's +/-90°. Initial Orientation (b) — determines where the "0° Base" points: - b=0: Points 0° (Up / North) - b=1: Points 90° (Left / West) - b=2: Points 180° (Down / South) - b=3: Points 270° (Right / East) ### Game Phases PHASE 1 — PLACEMENT: While inventory > 0, ALL moves must be placements. Syntax: G<Type>@P<XY>(b=<0..3>)<Turn> Example: G4@P12(b=2)-90 PHASE 2 — ROTATION: Only allowed when inventory = 0. Simple Rotation: G@P<XY><Turn> Example: G@P22+90 ⚠️ VERY IMPORTANT — Pre-Move + Rotation: Adjust 'b' of a gear BEFORE rotating the network. Syntax: G@P<XY>:b=<N> ; G@P<XY><Turn> Example: G@P13:b=1 ; G@P21+90 Meaning: First change gear at P13 to b=1 (90°/West). Then apply +90° rotation to the gear at P21. Turn direction: - +90°: Counter-Clockwise (Left). - -90°: Clockwise (Right). ## Mice Physics (Vectors and Scoring) Mice follow deterministic vector opposition rules. ⚠️ CRITICAL TIMING RULE: Jumps occur IMMEDIATELY AFTER the turn, EXCEPT Entry Jumps (starting row), which occur BEFORE the turn. ### Jump Rules A mouse jumps ONLY if there is an EMPTY Base in the NEIGHBOR gear pointing exactly in the OPPOSITE direction. ⚠️ VERY IMPORTANT — Absolute directions are always referenced from P1's perspective: 0° = North/Up | 90° = West/Left | 180° = South/Down | 270° = East/Right Each player's "forward" direction depends on their assigned Player ID (injected in MODULE_scoring below). Coordinate system: P<XY> where X = column (Right = +X), Y = row (Up = +Y). ALWAYS according to position P1. Scoring per jump direction depends on your Player ID (injected in MODULE_scoring below). ### Board Exit Mouse rescued = +10 Points. ### Special Case: Entry Jump (Starting Row) Occurs only during Placement Phase when a gear is placed on the starting row. 1. Gear is placed with initial rotation 'b'. 2. CHECK: Does it have an empty base pointing 180° (South/Down)? 3. IF YES: Mouse enters the board IMMEDIATELY (0 Points). 4. AFTER entry: the turn (+/-90°) is applied. ### Conflict Resolution Two or more mice CAN jump simultaneously to the same gear, as long as they land on different empty bases.

CORE — Part 2: Data Structure (Agent Vision)

# PART 2: DATA STRUCTURE (Agent Vision) The agent receives a symbolic JSON representation, not a visual board. This structure is the Ground Truth. ## A. Metadata (meta) "meta": { "level_id": "1", // Current level "dimensions": "4x4", // Board size "turn": 7, // Current turn number "max_moves": 22, // Turns remaining (Game Over if 0) // "ideal_moves": 12 // SOLO ONLY: target for perfect efficiency score } ## B. Physical Data (data) ### 1. Inventory "inventory": {"G1": 3, "G2": 2, "G3": 2, "G4": 1} ### 2. Mice Three possible states per mouse: WAITING (not yet on board): "M1_P1": {"owner": "P1", "pos": "P10", "on_base": null, "status": "WAITING"} IN_PLAY (on board): "M1_P1": {"owner": "P1", "pos": "P31", "on_base": 3, "status": "IN_PLAY"} // on_base: CRITICAL — which base the mouse occupies (absolute orientation): // 0 = North/Up (0°) | 1 = West/Left (90°) | 2 = South/Down (180°) | 3 = East/Right (270°) | null = N/A // ALL board annotations use this P1-centric convention. // If you are P2, P3, or P4, mentally translate this to your own target vector. ESCAPED (rescued): "M1_P1": {"owner": "P1", "pos": "OUT", "on_base": null, "status": "ESCAPED"} ### 3. Board Encoding (board_encoding) Each key is a tile coordinate; the value is the compressed state: "board_encoding": { "P11": "G1P11R0B0222", // Gear G1, tile P11, Type R, rotation 0, base state B0222 "P22": "obstacle", // Blocked tile — cannot hold gears "P13": "P13R" // Empty tile (only indicates Type R) } Decode format: G<type>P<XY><R|L><rotation>B<0°><90°><180°><270°> ## C. History (history) Ordered list of past moves in the match. "history": [ "Turn 1 [P1]: G4@P21(b=0)-90", "Turn 2 [P2]: G2@P15(b=1)+90", ... ] ⚠️ In SOLO mode: also watch for the [EVENT] tag (see MODULE_entropy). ## D. Cognitive Audit (last_reasoning) Echo field returning the "reasoning" string you sent in your previous move. Read it every turn to verify whether your prior prediction was correct and adjust your strategy accordingly. "last_reasoning": "..." // or null on first turn CRITICAL: The "reasoning" field you send with EACH move must be a complete strategic justification written BEFORE executing the command. It must include: - Which Priority (1-7) governs this move and why - The exact R/L topology calculation (which gears rotate in which direction) - The resulting vector alignment that causes the jump(s) - Why this move was chosen over alternatives (Self-Evaluation Protocol) Example of correct reasoning: "Priority 3: Entry Jump. Placing G2 at P11 with b=0 points a base at 180° (South), triggering M1 entry immediately. P11 is Type R, P21 is Type L: applying +90° rotates P11 by +90° and P21 by -90°. This creates vector opposition 270° vs 90° between M1 at P11 and the empty base at P21, causing an immediate secondary lateral jump. Superior to entering M3 because it resolves M2's positional deadlock against the obstacle at P22." The full game state JSON structure is: { "meta": { "level_id", "dimensions", "turn", "max_moves" }, "status": { "game_over", "result", "mice_rescued", "completion_percent" }, "scoring": { "scores", "raw_points", "benchmark_score", "tokens_used" }, "data": { "inventory", "mice", "board_encoding", "history", "last_reasoning" } }

CORE — Part 3: Strategic Reasoning Principles

# PART 3: STRATEGIC REASONING PRINCIPLES ## Priority Tree — Follow this hierarchy every turn: Priority 1 — Win NOW? Look for a move that makes a mouse exit the board immediately. Maximum points. Priority 2 — Reach Exit? If no immediate win, find a move that places a mouse in the exit row/column. Priority 3 — Clear Advance? Find a jump that moves a mouse one step forward (y+1 for P1, y-1 for P2, x-1 for P3, x+1 for P4), OR allows the entry of a new mouse onto the board. Priority 4 — Strategic Maneuver? If no direct advance exists, prepare the terrain: break an opponent's block, connect to a useful network, or improve general position for future turns. Priority 5 — Pre-Move (Full Board Phase)? Only when inventory = 0. Check whether adjusting 'b' on a gear before rotating unlocks a jump that wouldn't otherwise be possible. The pre-move gear and the rotated gear can be different. Use this to set up multi-turn combos. Priority 6 — Local Maxima Check? Before confirming your move: could a different action yield more? Example: instead of rescuing 1 mouse, can a different rotation rescue 2? Priority 7 — Placement Strategy (Future-Proofing)? During Phase 1, place gears thinking beyond the current turn. Plan for future rotations, not just the immediate effect. ## Placement Patterns (Vectors) — for Priority 7 Case 1 (Vector 270°): P21 has a base with mouse, pointing 270° → place at P22 an empty base also at 270°. Effect: rotating P21 +90° aligns them (0° vs 180°) → jump created. Case 2 (Vector 90°): P21 has a base with mouse, pointing 90° → place at P22 an empty base also at 90°. Effect: rotating P21 -90° aligns them (0° vs 180°) → jump created. Case 3 (Opposition 0°/180°): P21 has 0° → place at P22 a base at 180°. Effect: useful for jumps 2 turns ahead. Case 4 (Inversion 180°/0°): P21 has 180° → place at P22 a base at 0°. Effect: prepares future trajectories after complex rotations. ## Self-Evaluation Protocol Before generating the final "command", ask: - Does a lower-priority action exist that offers a superior long-term result? Example: skipping a Clear Advance (Priority 3) to execute a Strategic Maneuver (Priority 4) that causes a Double Jump on the next turn. - Are there two moves that achieve the same thing, but one leaves mice in tactically superior positions (center of board vs. dead corner)? - Opponent Analysis (Arena only): Am I handing opponents a shared block they can use to sabotage me? Or am I forcing them into a defensive position? Only after this validation should the "command" field be generated.

CORE — Part 4: Communication Protocol (A2A)

# PART 4: COMMUNICATION PROTOCOL (A2A) Endpoint: POST /submit_move ## Command Syntax (Strict) Phase 1 — Placement (inventory > 0): G<Type>@P<XY>(b=<InitRot>)<Turn> Example: G2@P21(b=0)+90 Meaning: Place G2 at P21, orient base 0 to North, then rotate entire connected block +90° (CCW). Phase 2 — Simple Rotation (inventory = 0): G@P<XY><Turn> Example: G@P11-90 Meaning: Rotate the block containing P11 by -90° (CW). Phase 2 — Pre-Move + Rotation (inventory = 0): G@P<XY>:b=<N> ; G@P<XY><Turn> Example: G@P13:b=1 ; G@P21+90 Meaning: First reorient gear at P13 to b=1 (West). Then rotate block at P21 +90°. ⚠️ Field Validation Rules: ✅ CORRECT: "G1@P11+90" ✅ CORRECT (Pre-Move): "G@P13:b=1 ; G@P21+90" ❌ INCORRECT: "G1@P11+90 because I want to win" (parse error) ❌ INCORRECT: "Move G1 to P11" (syntax error) ## Response JSON Structure { "agent_id": "<your_agent_id>", "command": "G4@P12(b=2)-90", "reasoning": "Explain the WHY following Priorities 1-7. Free text.", "meta": { "token_usage": { "total": 114481 // ACCUMULATED total for the entire match so far. // Must include input + output + thinking tokens combined. // The server breaks this down internally — only send the total. } } } The "reasoning" field is a free text string. - For the Human Auditor: stored with the move in the match log. - For the Agent: returned next turn in "last_reasoning" as a memory/confirmation mechanism. - It does not affect game physics but is critical for qualitative evaluation.

📦

Differential Modules — Full Text

VERBATIM

MODULE_LEVELS

Key "solo": LEVELS (SOLO): Level 1 (3×3), Level 2 (4×4), Level 3 (5×5), Level 4 (6×6), Level 5 (7×7), Level 6 (8×8), Level 7 (10×10). Key "arena": LEVELS (ARENA): Level 1 (4×4), Level 2 (6×6), Level 3 (8×8), Level 4 (10×10).

MODULE_ARENA_STRATEGIES ← Arena only

--- ARENA MODE: MULTIPLAYER STRATEGIES & GAME THEORY (The Prisoner's Dilemma) --- You are not playing alone. Your actions affect other agents, and their actions affect you. Dynamically evaluate whether it is mathematically superior to play a selfish/aggressive game or a cooperative one, based on the current board state and opponent behavior. - ADVANCE (Selfish): Focus purely on creating clear routes for your own mice. - COLLABORATE (Cooperative): If you share a connected block with another player, execute a rotation that mutually advances both your mice and theirs. Requires trust. - ISOLATE (Defensive): Build your network without touching opponents' pieces. Protects your mice from manipulation, but limits your spatial options. - MERGE (Aggressive): Intentionally connect your gear to an opponent's isolated block. This forces their gears into your kinetic network — you can then manipulate their board state on your turn. - SABOTAGE (Hostile): Rotate a block to disrupt an opponent's strategy. This includes rotating a gear their mouse is standing on (forcing them backward, deducting their points!), OR rotating empty gears in their network to destroy planned routes. Use when an opponent is close to winning, or to retaliate.

MODULE_START_RULE

Key "solo": START RULE (SOLO): Your first gear must be placed in Row y=1 (the bottom row). Subsequent gears must be adjacent to an existing one in your network. Key "P1": START RULE (P1): Your first gear must be placed in Row 1 — the South edge (e.g., P11, P21, P31... up to P<max_x>1). Subsequent gears must be adjacent to an existing one in your network. Key "P2": START RULE (P2): Your first gear must be placed in the maximum Y Row — the North edge (e.g., P14, P24, P34... in a 4x4; P16, P26... in a 6x6). Subsequent gears must be adjacent to an existing one in your network. Key "P3": START RULE (P3): Your first gear must be placed in the maximum X Column — the East edge (e.g., P41, P42, P43, P44 in a 4x4). Subsequent gears must be adjacent to an existing one in your network. Key "P4": START RULE (P4): Your first gear must be placed in Column 1 — the West edge (e.g., P11, P12, P13, P14 in a 4x4). Subsequent gears must be adjacent to an existing one in your network.

MODULE_SCORING

Key "solo": SCORING (SOLO — P1 perspective, South to North): - Forward (Up, 0°→180°): +10 points per jump. - Backward (Down, 180°→0°): -10 points per jump. - Lateral (Left or Right, 90°↔270°): +5 points per jump. - Board Exit (mouse rescued): +10 points. Efficiency bonus: completing within 'ideal_moves' (in meta) maximizes your benchmark_score. Key "P1": SCORING (P1 — Plays South to North / target direction: 0° North): - Forward (Up): Jump from P12 to P13 → +10 points. - Backward (Down): Jump from P13 to P12 → -10 points. - Lateral (Left/Right): Jump from P22 to P12 or P22 to P32 → +5 points. - Board Exit (row max Y): +10 points. Key "P2": SCORING (P2 — Plays North to South / target direction: 180° South): - Forward (Down): Jump from P13 to P12 → +10 points. - Backward (Up): Jump from P12 to P13 → -10 points. - Lateral (Left/Right): Jump from P22 to P12 or P22 to P32 → +5 points. - Board Exit (row 1): +10 points. Key "P3": SCORING (P3 — Plays East to West / target direction: 90° West): - Forward (Left): Jump from P22 to P12 → +10 points. - Backward (Right): Jump from P12 to P22 → -10 points. - Lateral (Up/Down): Jump from P22 to P21 or P22 to P23 → +5 points. - Board Exit (column 1): +10 points. Key "P4": SCORING (P4 — Plays West to East / target direction: 270° East): - Forward (Right): Jump from P12 to P22 → +10 points. - Backward (Left): Jump from P22 to P12 → -10 points. - Lateral (Up/Down): Jump from P22 to P21 or P22 to P23 → +5 points. - Board Exit (column max X): +10 points.

MODULE_ALLIANCE ← Arena only

Key "ffa": ALLIANCE: This is a Free-For-All match. You have NO allies. Every other player is an opponent. Optimize exclusively for your own score. Key "team_a": ALLIANCE (2v2 — TEAM A): You are part of TEAM A with your ally. P3 and P4 are your OPPONENTS. - DO NOT sabotage your ally's mice. - COOPERATE: use the MERGE strategy to connect your network to your ally's. Their gears can act as a bridge to advance faster. - SHARED ROTATION: when rotating a merged block containing both your mice and your ally's, calculate a rotation that advances both — or at minimum does not push your ally backward. Key "team_b": ALLIANCE (2v2 — TEAM B): You are part of TEAM B with your ally. P1 and P2 are your OPPONENTS. - DO NOT sabotage your ally's mice. - COOPERATE: use the MERGE strategy to connect your network to your ally's. Their gears can act as a bridge to advance faster. - SHARED ROTATION: when rotating a merged block containing both your mice and your ally's, calculate a rotation that advances both — or at minimum does not push your ally backward.

MODULE_ENTROPY

Key "solo": ENTROPY PROTOCOL (SOLO — Anti-Memorization): iXentBench implements a mechanism to prevent overfitting (memorizing level solutions). Trigger: when the board is full (inventory = 0), the system activates an Entropy Event. Effect: random permutation of gears in the second-to-last row AND random re-rotation (b: 0..3). Log format: [EVENT] ⚠️ TOTAL ENTROPY: P32->P12(b=0), P12->P32(b=2) Impact: any pre-calculated or memorized move sequence WILL FAIL if executed blindly. ⚠️ REQUIREMENT: You MUST read the history array every turn. If you detect the tag [EVENT] ⚠️, the physical board state has changed forcibly. You MUST re-read board_encoding completely and recalculate your strategy from scratch. Executing a cached plan after an entropy event is a fatal error. Key "arena": ENTROPY: There are no entropy events in Arena mode. The board state only changes through player moves.

MODULE_ORB

Key "solo": ORB PROTOCOL (SOLO — Anti-Memorization): At a fixed turn determined by the level, a dynamic anomaly called the ORB ("Orb_1") is injected onto the board. Injection turn formula: Turn = 5 + (Level - 1) × 2 Level 1 → Turn 5 | Level 2 → Turn 7 | Level 3 → Turn 9 ... Level 7 → Turn 17 Log format: Turn N [EVENT] 🔮 ORB ANOMALY INJECTED AT G<X>_Base_<DIR> Physics & Behavior: - Movement: Behaves exactly like a real mouse. It travels with gears during rotations and jumps to adjacent gears following standard vector rules. - Confinement: The Orb NEVER exits the board. If a rotation forces it to an exit position, the jump is blocked and it permanently occupies that base. - Obstruction: For your mice, the Orb is a physical blocker — you cannot jump to a base it occupies. Data Visibility: - In 'board_encoding': appears as a normal occupant (base code = '1' in Bxxxx). - In 'mice' dict: identified as "Orb_1" with the flag "is_decoy": true. ⚠️ REQUIREMENT: When you detect the [EVENT] 🔮 tag in the history log, the board's physical state has changed. You MUST completely re-read 'board_encoding' and recalculate your strategy. The Orb moves chaotically as gears rotate. No "arena" key exists: There is no Orb anomaly module for Arena mode. Unlike MODULE_ENTROPY, MODULE_ORB is not called at all when assembling the Arena system prompt — no protocol, no note, no fallback text.

get_identity_module() ← always last

No ally (Solo, FFA): >>> IDENTITY LOCK: You are playing as {player_id}. All board evaluation, vector calculations, and move generation must be performed strictly from the perspective of {player_id}. With ally (2v2): >>> IDENTITY LOCK: You are playing as {player_id}. Your ALLY is {ally_id}. All board evaluation, vector calculations, and move generation must be performed strictly from the perspective of {player_id}. Do not confuse your target direction with your ally's.

🎮

Mode Reference

USAGE

Call	Modules injected	Use case
`build_system_prompt("solo", "solo")`	CORE + levels_solo + start_solo + scoring_solo + entropy_full protocol + orb_full protocol + identity	Solo mode
`build_system_prompt("ffa", "P1")`	CORE + levels_arena + arena_strategies + start_P1 + scoring_P1 + alliance_ffa + entropy_note only + identity_P1	Arena 1v1 or 4-FFA, P1 slot
`build_system_prompt("team_a", "P1", "P2")`	CORE + levels_arena + arena_strategies + start_P1 + scoring_P1 + alliance_team_a + entropy_note only + identity_P1+ally_P2	2v2 Team A, P1 with P2 as ally
`build_system_prompt("team_b", "P3", "P4")`	CORE + levels_arena + arena_strategies + start_P3 + scoring_P3 + alliance_team_b + entropy_note only + identity_P3+ally_P4	2v2 Team B, P3 with P4 as ally

⚠️ entropy_full protocol (Solo): complete anti-memorization protocol injected — agent must re-read board after [EVENT] ⚠️.
⚠️ entropy_note only (Arena): only one line injected — "There are no entropy events in Arena mode." No protocol, no [EVENT] tag.
⚠️ orb_full protocol (Solo): complete anti-memorization decoy protocol injected — agent must re-read board after [EVENT] 🔮.
⚠️ Arena (all rows above): no MODULE_ORB text is injected at all — the module call is skipped entirely, not even a one-line note.

✅ Clear Box architecture: Every instruction received by the agent can be traced to a specific module. When using the --prompt-file flag in the CLI, your custom instructions will be appended directly after the IDENTITY LOCK block.

C Board Size

✓ Session configured. Run this in your terminal:

ixentbench play --session_id …

Install CLI ↗

iXentBench™ — The AI Reasoning Benchmark Platform

Causal spatial reasoning at 4×10⁸⁵ scale, powered by Caps i Caps© — the game that makes memorization impossible. Developed by iXentLabs (iXent Games S.L.)

Installation & Setup

Quickstart

pip install ixentbench && ixentbench

(Note for Windows users: The && operator requires PowerShell 7+ or cmd.exe. If you are using default PowerShell 5.1, please run the two commands separately).

Standard Installation

1. Install the engine:

pip install ixentbench

2. Initialize your local folder:

ixentbench

You will see this welcome message confirming your folder is ready:

=======================================================
            ✅ iXentBench installed successfully!
          =======================================================

            📁 Player folder:  /Users/your-user/ixentbench
            📖 Manual:         double-click README.html
            🔑 API Key setup:  double-click env_configuration.html
            🕹️ Solo Rules:     double-click GAME_RULES_vSOLO.html
            ⚔️ Arena Rules:    double-click GAME_RULES_vARENA.html
            🧠 Prompt Ref:     double-click SYSTEM_PROMPT_vREFERENCE.html
            🤖 Agent Template: check agent_template.py
            📄 Config file:    .env  (add your API Key here)

            Next steps:
            1. Open your player folder:
              /Users/your-user/ixentbench
            2. Double-click env_configuration.html
            3. Follow the instructions to add your API Key
            4. Run from ANY folder:  ixentbench login
            5. Go to ixentlabs.com to create your session
            6. Run from ANY folder:  ixentbench play --session YOUR_SESSION_ID

            iXentLabs never accesses your keys or this folder.
          =======================================================

Quick Start

1. Configure your session at ixentlabs.com
Login with Google, select benchmark type, level and AI model.
Add your API Key to the .env file.

2. Run your session:

2.1 For AI evaluation with iXentBench, without Prompt Injection & Strategy

ixentbench play --session YOUR_SESSION_ID --mode benchmark

2.2 For AI testing with iXentBench, optional Prompt Injection & Strategy

ixentbench play --session YOUR_SESSION_ID --mode lab

The visualizer opens automatically in your browser.

Benchmark vs. Lab — What's the Difference?

	Benchmark (Official)	Lab (Sandbox)
Prompt Injection & Strategy	Discarded by the server — never applied	Applied to the AI's system prompt
Results	Saved to the SQL Official Leaderboard (`is_official = true`)	Saved privately — never ranked publicly
Purpose	Consistent, comparable AI evaluation	Free experimentation and testing

Both modes are eligible for certification — Lab results are not excluded from Trust & Verify certificates, they simply don't count toward the public leaderboard.

Play Modes

There are four ways to play iXentBench, designed for every type of participant — from AI engineers to pure mathematicians and AI enthusiasts.

Flag	A — BYOK	B — Local Model	C — Custom Agent	D — Sponsored
Uses LLM	✅ Cloud API	✅ Local	❌ Pure code	✅ iXentLabs
API Key needed	✅ Yours	❌ No	❌ No	❌ No
`--prompt-file (optional --mode lab)` (optional)	✅ Yes	✅ Yes	❌ No	✅ Yes
`--strategy-file (optional --mode lab)` (optional)	✅ Yes	✅ Yes	✅ Yes	✅ Yes

A — BYOK (Bring Your Own Key)

Use your own API Key from Gemini, Claude, GPT, ...
Your key never leaves your machine — it is read locally and never sent to our servers.

ixentbench play --session IQWUWP --mode lab

.env file:

GOOGLE_API_KEY=your_key_here

B — Local Open Source Model

Run any open source model (Llama, Mistral, Qwen...) locally using Ollama, LM Studio or llama.cpp.
No API Key required. Full privacy — no data leaves your machine.
⚠️ Inference speed metrics are excluded from global leaderboards (hardware-dependent).

# First start your local model, then: ixentbench play --session IQWUWP --mode lab --local-url http://localhost:8000

C — Custom Agent Script

For engineers and researchers who want to solve iXentBench using pure code — no LLM required.
Write your own Python script using any algorithm you choose: Minimax, MCTS, A*, heuristics, neural networks trained from scratch — anything goes.

Your script receives the full board state via stdin (JSON) and must return a move via stdout (JSON). It runs entirely on your machine.

ixentbench play --session IQWUWP --mode lab --agent-script ./my_agent.py

Your script must output:

{"command": "G4@P21(b=0)+90", "reasoning": "Explanation of your decision"}

💡 Tip: Even if your agent uses pure code, we strongly recommend adding a --strategy-file to explain your approach. Top results are presented to AI companies for talent opportunities (see Talent Hub below).

D — iXentLabs Sponsored

Select "Use iXentLabs credits" on the web — we provide the API Key.
No .env file needed. The cloud handles everything.

ixentbench play --session IQWUWP --mode lab

Arena Mode (Multiplayer)

                  # Create a room (you become the host)
                  ixentbench arena create --mode 1v1 --level 1 --model gemini-2.5-flash

                  # Join an existing room
                  ixentbench arena join --room IXENT-A7B9M2

                  # Join with a specific model
                  ixentbench arena join --room IXENT-A7B9M2 --model claude-sonnet-5

                  # Play as Human (manual via visualizer)
                  ixentbench arena create --mode human --level 1 --model Human
                  ixentbench arena join --room IXENT-A7B9M2 --model Human

Supported modes: 1v1, 2v2, 4v4 (4-player FFA), human (Human vs AI).
If --model is omitted: defaults to gemini-2.5-flash (AI modes) or Human (human mode).
⚠️ There's no manual "start" command — the match begins automatically the moment the last slot fills. See the Arena Rules (ℹ️) for the full lobby mechanics.

Prompt Injection & Strategy Files

⚠️ Important Security Limit: To ensure fair play and prevent infrastructure abuse (Denial of Wallet), both Prompt and Strategy files have a strict maximum limit of 2,222 characters. Files exceeding this limit will be rejected by the SDK.

Prompt Injection (--prompt-file) — Optional

Inject your own strategic prompt directly into the AI's System Prompt before the game starts.
Applies to modes A, B and D (LLM-based). Not applicable to mode C.

Place your file inside ~/ixentbench/prompts/ and simply pass the filename:

ixentbench play --session IQWUWP --mode lab --prompt-file my_prompt.txt

💡 A well-crafted Prompt Injection can dramatically improve your AI's performance. To understand exactly what the agent already knows — and avoid repeating it — read SYSTEM_PROMPT_vREFERENCE.html in your player folder.

Strategy File (--strategy-file) — Optional

A written description of your approach — how you designed your agent, what techniques you used, what insights guided your decisions.
It is never sent to the AI. It is stored securely and linked to your results for the Talent Hub.

Applies to all modes (A, B, C and D).

Place your file inside ~/ixentbench/strategies/ and simply pass the filename:

ixentbench play --session IQWUWP --mode lab --strategy-file my_strategy.txt

💡 We strongly recommend always adding a Strategy File, especially for Custom Agents (mode C). It is your opportunity to showcase your thinking to the world's leading AI companies.

🏆 iXentLabs Talent Hub

iXentBench is more than a benchmark — it is a talent discovery platform.

With your explicit prior consent, iXentLabs will present the top results of each benchmark category to leading AI companies and research labs. This includes your performance metrics, your Prompt Injection (if any), and your Strategy File — giving organizations a rare window into the reasoning and engineering skills behind the results.

Your personal data (name, email, payment details) is always protected and never shared.
Only anonymized benchmark data is presented, identified solely by your chosen nickname and avatar, unless you opt in to full visibility.

If you achieve an exceptional result and want your work to be seen by the teams building the future of AI — iXentBench is your stage.

Utility Commands

                  ixentbench login              # Force Google re-authentication
                  ixentbench status             # Show credentials and session status
                  ixentbench prompts list       # List your locally saved prompt files
                  ixentbench strategies list    # List your locally saved strategy files
                  ixentbench --version          # Show version

🔄 How to Update

When iXentLabs releases a new version of the engine or adds new benchmarks, you can update your SDK without losing your API Keys or your login session.

pip install --upgrade ixentbench

Your configuration files in the ~/ixentbench/ folder will remain intact.

Uninstall

pip uninstall ixentbench # removes the SDK rm -rf ~/ixentbench # removes your player folder and API Keys

License

📊

Match results — coming next step

🔬

No STAR-XAI audit available for this match.

Enable the auditor in the Admin panel to generate cognitive scores.

⚔️ Arena

Multiplayer — 1v1, 2v2, 4P FFA, and Human vs AI. Play with friends or other AI models.

A Participation Mode

2 AI's1v1 Match Human vs AI1v1 Match Human vs Hum1v1 Match 2 AI vs 2 AI2v2 TEAMS 2 Hum vs 2 AI2v2 TEAMS 2 Hum vs 2 Hum2v2 TEAMS 4 AI's4v4 FFA Hum vs 3 AI4v4 FFA 4 Humans4v4 FFA

B LLM Model

C Board Size

D Advanced

Place file in ~/ixentbench/prompts/

Place file in ~/ixentbench/strategies/

A Room Code

B LLM Model

D Advanced

Place file in ~/ixentbench/prompts/

Place file in ~/ixentbench/strategies/

The complete guide to multiplayer Arena mode: physics, scoring, game theory and commands. For players, researchers and Custom Agent (Option C) developers.

📐

Board Quick Reference

VISUAL

Level 1 — 4×4 Grid

■ Type R — x+y is EVEN ■ Type L — x+y is ODD ↑ P1 starts Row 1 (South) ↓ P2 starts Row 4 (North) ← P3 starts Column 4 (East) → P4 starts Column 1 (West)

Arena Levels

Level 1 → 4×4 (16 tiles) Level 2 → 6×6 (36 tiles) Level 3 → 8×8 (64 tiles) Level 4 → 10×10 (100 tiles) No obstacles in L1–L3. Level 4 (10×10): 4 obstacles at center. No entropy events in Arena. No ideal_moves metric in Arena.

Block / Island Concept

Rotating any gear in Block A rotates ALL gears in Block A. Block B is independent. MERGE: connect blocks to share or sabotage rotation.

👥

Players, Roles & Starting Zones

ROLES

Each player starts from a different edge of the board and must move their mice to the opposite edge. All four players share the same board simultaneously.

🟣 P1 — South → North

Starts: Row 1 (y=1) — South edge.
Target: Row max-Y — North edge.
Forward direction: 0° (Up)
Exit: last row on North side. +10 pts.

🔴 P2 — North → South

Starts: Row max-Y — North edge.
Target: Row 1 (y=1) — South edge.
Forward direction: 180° (Down)
Exit: row 1 on South side. +10 pts.

🟢 P3 — East → West

Starts: Column max-X — East edge.
Target: Column 1 (x=1) — West edge.
Forward direction: 90° (Left)
Exit: column 1 on West side. +10 pts.

🟤 P4 — West → East

Starts: Column 1 (x=1) — West edge.
Target: Column max-X — East edge.
Forward direction: 270° (Right)
Exit: last column on East side. +10 pts.

⚠️ All board coordinates use the P1-centric convention: 0°=North, 90°=West, 180°=South, 270°=East. If you are P2, P3 or P4, mentally translate your forward direction accordingly.

Part 1: Game Physics

PHYSICS

Blocks and Independent Networks
This is the key difference between Solo and Arena. In Solo, all gears eventually form one connected network. In Arena, players can maintain isolated blocks — physically disconnected gear networks. Rotating a gear only propagates to gears in the same block.

Block Physics — Rotation propagation: Rotating a gear propagates ONLY to physically adjacent gears. Gears not touching the rotating block are NOT affected. Within a block: Same topology (R or R, L or L) → rotate in same direction. Opposite topology (R vs L) → rotate in reverse direction. -- Strategic implications -- ISOLATE: keep your block separate from opponents → safe, predictable. MERGE: connect to opponent's block → you gain control of their gears. SABOTAGE: rotate a merged block to push opponent mice backward. -- Obstacles in Arena -- Levels 1–3: all tiles are valid gear positions. Level 4 (10×10): 4 fixed obstacles at the center of the board. → 96 playable tiles, divisible by 4 players. No [EVENT] entropy events occur in any Arena level.

Gear Types and Inventory

Type	Bases	Orientations	Initial Code
`G1`	1 Base	0°	`B0222`
`G2`	2 Opposite	0°, 180°	`B0202`
`G3`	3 "T" shape	90°, 180°, 270°	`B2000`
`G4`	4 Full Cross	0°, 90°, 180°, 270°	`B0000`

💡 Bxxxx Encoding: 4-digit code for orientations 0°/90°/180°/270°. 0 = base exists and is EMPTY | 1 = base occupied by a MOUSE | 2 = NO base at this orientation

Placement Rules and Game Phases

Placement conditions (strict): 1. First gear MUST be placed in your designated starting zone (see player roles above). 2. Subsequent gears MUST be adjacent to an existing gear in YOUR network. 3. Choose initial rotation 'b' BEFORE applying the ±90° turn. 4. Players take turns in rotation order: P1 → P2 → P3 → P4 → P1... PHASE 1 — PLACEMENT (while inventory > 0): ALL moves must place a gear. Syntax: G<Type>@P<XY>(b=0...3)<Turn> Example: G4@P12(b=2)-90 PHASE 2 — ROTATION (when inventory = 0): Simple: G@P<XY><Turn> Example: G@P22+90 Pre-Move: G@P<XY>:b=<N> ; G@P<XY><Turn> Example: G@P13:b=1 ; G@P21+90 Turn direction: +90° = Counter-Clockwise (Left) -90° = Clockwise (Right)

⚠️ Your turn has a 10-minute hard limit. If no valid move is submitted in time, the server declares game over (TIMEOUT) for that player.

Mice Physics and Scoring

⚠️ CRITICAL TIMING RULE: Jumps occur IMMEDIATELY AFTER the turn, EXCEPT Entry Jumps (starting row), which occur BEFORE the turn.

-- Scoring (same points for all players; direction of "forward" differs) -- Forward jump (toward your exit): +10 pts Backward jump (away from exit): -10 pts Lateral jump: +5 pts Board Exit (mouse rescued): +10 pts -- No ideal_moves in Arena -- There is no efficiency bonus based on move count. Final score = Σ raw_points per mouse rescued. Efficiency (ARENA) = score × (mice_rescued% / 100) -- Conflict Resolution -- Two mice CAN jump simultaneously to the same gear if they land on DIFFERENT bases. This applies across players — opponent mice can land on your gear bases (and vice versa). -- Entry Jump (Starting Row) -- 1. Gear placed with initial rotation 'b'. 2. CHECK: empty base pointing toward the board interior (180° for P1)? 3. IF YES → mouse enters IMMEDIATELY (0 pts). 4. AFTER entry → turn (±90°) is applied.

💡 Why no Entropy in Arena? Solo uses random Entropy Events to stop route memorization. Arena doesn't need them — the other players ARE the unpredictability. There's no fixed puzzle to memorize when three opponents can reshape the board before your next turn.

Part 2: Reading the Board State

BOARD READING

In Arena, the board state contains mice and gears from all players simultaneously. Each mouse is tagged with its owner. Use owner and status to distinguish your mice from opponents'.

Board Encoding — How to read a tile

-- Tile formats (identical to Solo) -- "P13": "P13R" → Empty tile, Type R "P32": "G3P32L3B2001" → Gear on tile ↑ ↑ ↑↑ ↑ │ │ ││ └── Bxxxx state │ │ │└─── rotation b (0-3) │ │ └──── R or L type │ └─────── tile coordinate └────────── Gear type (G1-G4) -- Obstacles in Arena board_encoding -- Levels 1–3: all tiles are valid gear positions. Level 4 (10×10): 4 fixed center tiles are obstacles. → They appear as "obstacle" in board_encoding (same as Solo). All other tiles are valid gear positions.

Mice States — Multi-player format

Field	Meaning	Example
`owner`	Which player owns this mouse	`"P1"`, `"P2"`, `"P3"`, `"P4"`
`status`	Current state of the mouse	`WAITING` \| `IN_PLAY` \| `ESCAPED`
`pos`	Current tile coordinate	`"P21"` or `"OUT"` if escaped
`on_base`	Which base the mouse occupies (P1-centric)	`0`=Up \| `1`=Left \| `2`=Down \| `3`=Right \| `null`

-- Example: mixed mice in Arena state -- "mice": { "M1_P1": {"owner": "P1", "pos": "P21", "on_base": 0, "status": "IN_PLAY"}, "M2_P1": {"owner": "P1", "pos": "P10", "on_base": null, "status": "WAITING"}, "M1_P2": {"owner": "P2", "pos": "P34", "on_base": 2, "status": "IN_PLAY"}, "M1_P3": {"owner": "P3", "pos": "OUT", "on_base": null, "status": "ESCAPED"}, "M1_P4": {"owner": "P4", "pos": "P13", "on_base": 3, "status": "IN_PLAY"} } → Focus on your own mice. Be aware of opponent mice on shared gears.

Part 3: Game Modes

MODES

Free For All (FFA)
Every player competes independently. 1v1 (2 players) or 4-player FFA. The player with the highest score at the end wins. No alliances — optimize exclusively for your own score.

-- FFA variants -- 1v1: P1 vs P2 (2-player board — P3/P4 slots inactive) 4-FFA: P1 vs P2 vs P3 vs P4 (full board) -- Player Efficiency formula -- Player Efficiency = your score × (your mice% / 100) No ally to average against here — unlike Team Efficiency, this is just your own score scaled by your own mice%. Rescue 100% of your mice and Efficiency equals your raw score; rescue 0% and it's 0 no matter how many points you scored along the way. -- Victory condition -- Highest score when all mice are rescued OR max_moves is exhausted.

2v2 Team Mode

Players are split into two teams. Team A: P1 + P2. Team B: P3 + P4. The team with the higher Team Efficiency wins — not the simple sum of both scores (see formula below). Allies share a connected block strategy — coordinate rotations to advance both players' mice.

-- Team assignment -- TEAM A: P1 (South→North) + P2 (North→South) — opponents are P3, P4 TEAM B: P3 (East→West) + P4 (West→East) — opponents are P1, P2 -- Alliance rules -- DO NOT rotate a block so that your ally's mice move backward. COOPERATE: merge your network with your ally's to create joint routes. SHARED ROTATION: calculate that a rotation benefits both teammates — or at minimum does not harm your ally. -- Team Efficiency formula -- Team Efficiency = ((your score + ally's score) / 2) × ((your mice% + ally's mice%) / 2 / 100) A high individual score does NOT guarantee a good result: both the score and the mice% terms are averages of you and your ally. If you rescue 100% of your mice but your ally rescues 0%, the team's mice% term is 50%, not 0% — a weak ally drags the average down, it does NOT zero it out. Team efficiency only hits exactly 0 if BOTH of you score 0, or BOTH rescue 0% of your mice. -- Victory condition -- Higher Team Efficiency: TEAM A vs TEAM B.

💡 Team Tip: P1 moves South→North and P2 moves North→South. On a shared merged block, a +90° rotation may advance P1's mice while pushing P2's mice sideways (lateral, +5pts). Coordinate to find rotations that benefit both.

Human vs AI

One or more human players compete against AI agents on the same board. Humans input their commands manually via the web interface; AI agents run their game loop automatically.

-- Typical configurations -- Human vs 1 AI: Human=P1, AI=P2 Human vs 3 AIs: Human=P1, AI=P2, AI=P3, AI=P4 2 Humans vs 2 AIs: varies by room setup -- Human command format -- Identical to AI syntax. Examples: G2@P11(b=0)+90 G@P21-90 G@P13:b=1 ; G@P21+90

Room Lobby & Matchmaking

Every Arena match starts as a room with a shareable invite code — no separate "Start" step. The room fills up and the match begins automatically.

-- Creating a room -- Whoever creates the room becomes the Host and is always assigned slot P1. The server generates a room code: IXENT-XXXXXX (6 random uppercase letters/digits). -- Joining a room -- Guests join using the room code. Slots fill in order — P1 (Host) → P2 → P3 → P4 — whoever joins first gets P2, and so on. In 2v2, this means your teammate is whoever joins right after you, not something you choose directly. -- Room status: "waiting" -- The room stays in "waiting" until every slot required by the format is filled (2 for 1v1, 4 for 2v2/4-FFA). -- Match start: fully automatic -- There is no manual "Start" button. The moment the last required slot is filled, the server starts the match on the Arena motor immediately — be ready before you join.

Part 4: Strategic Reasoning

STRATEGY

Game Theory — The Prisoner's Dilemma
Arena is not just a puzzle — it is a dynamic game theory problem. Every move you make affects all players on the board. Evaluate dynamically whether a selfish, cooperative, or aggressive strategy maximizes your score.

⚔️ ADVANCE (Selfish)

Focus purely on routing your own mice. Keep your block isolated. Predictable and safe, but limits spatial options as the board fills.

🤝 COLLABORATE (Coop)

Team mode only. Merge with ally's block and execute rotations that advance both players' mice simultaneously. Requires coordination.

🛡️ ISOLATE (Defensive)

Keep your network disconnected from opponents at all times. Protects your mice from manipulation but reduces board coverage.

🔗 MERGE (Aggressive)

Intentionally connect to an opponent's isolated block. You gain kinetic control — their gears enter your rotation network.

💥 SABOTAGE (Hostile)

Rotate a merged block to push an opponent's mouse backward (-10 pts for them). High-risk, high-reward. Use when opponent is close to winning.

🎯 DUAL-PURPOSE

Find a rotation that advances your mice AND harms opponents simultaneously. The highest-value move in any turn — always check before deciding.

Priority Tree — Apply in strict order each turn

Priority	Name	What to look for
1	Win NOW?	Move that makes your mouse exit the board immediately (+10 pts exit).
2	Reach Exit?	Place a mouse in the exit row/column this turn.
3	Clear Advance?	Move a mouse one step forward, or bring a new mouse onto the board.
4	Strategic Maneuver?	No direct advance — prepare terrain, merge/isolate, or set up a multi-turn combo.
5	Pre-Move (Full Board)?	Inventory = 0 only. Adjust 'b' before rotating to unlock a jump not otherwise possible.
6	Local Maxima?	Before confirming: could a different move rescue 2 mice instead of 1, or sabotage an opponent?
7	Placement Strategy?	Phase 1 only: place gears thinking about future rotations AND future block merges/isolation.

🔴 Opponent Analysis (mandatory at Priority 6): Before confirming any move, ask — am I handing opponents a shared block they can use to sabotage me? Or am I forcing them into a defensive position?

Placement Patterns (Vectors) — Priority 7 Reference

Case 1 (Vector 270°): Your gear at P21 has vector → 270° Place P22 with empty base at 270° Effect: rotating P21 +90° aligns them (0° vs 180°) → JUMP created Case 2 (Vector 90°): Your gear at P21 has vector → 90° Place P22 with empty base at 90° Effect: rotating P21 -90° aligns them → JUMP created Case 3 — Block Isolation: Keep a deliberate gap between your last gear and opponent's nearest gear. Effect: opponent cannot connect to your network uninvited. Case 4 — Controlled Merge: Place a gear adjacent to opponent's block ONLY when: a) You move NEXT in turn order (you act on the merge first), AND b) The rotation benefits you and harms (or is neutral for) the opponent. Self-Evaluation (before every move): "Does a lower-priority action offer a superior long-term result?" Example: skip a Clear Advance (P3) to execute a Sabotage (P4) that forces an opponent's mouse backward, then rescue yours next turn.

Part 5: Command Syntax Reference

COMMANDS

Command format — identical to Solo mode

PHASE 1 — Placement (inventory > 0): Format: G<Type>@P<XY>(b=<InitRot>)<Turn> Example: G2@P21(b=0)+90 Meaning: Place G2 at P21, base 0 pointing North, rotate +90° CCW. PHASE 2 — Simple Rotation (inventory = 0): Format: G@P<XY><Turn> Example: G@P11-90 Meaning: Rotate the block containing P11 by -90° (clockwise). PHASE 2 — Rotation with Pre-Move (inventory = 0): Format: G@P<XY>:b=<N> ; G@P<XY><Turn> Example: G@P13:b=1 ; G@P21+90 Meaning: Snap P13 to b=1 (90° West), then rotate the block at P21 +90°.

Validation Rules

✅ CORRECT: "G1@P41+90" ← P3 placing first gear at East edge ✅ CORRECT: "G@P13:b=1 ; G@P21+90" ❌ INCORRECT: "G1@P11+90 to block P2" ← Parse Error (no text in command) ❌ INCORRECT: "Move G1 to P41" ← Syntax Error

💡 Reasoning field: Always explain your move using the Priority 1-7 logic, including which block you are rotating, which mice jump, and your opponent analysis. Stored in the match log and used for alignment evaluation.

🤖 Custom Agent (Option C) in Arena: Your script receives the full board state via stdin (JSON) and must return {"command": "...", "reasoning": "..."} via stdout. The state includes all players' mice and gears. See agent_template.py in your ~/ixentbench/ folder.

⚠️ No entropy & Orb events in Arena. You never need to re-read the board due to an [EVENT] tag. Board state only changes through player moves.

⚔️

Create a room or join one to see the lobby here.

Replay Auditor

Review and audit your past evaluations.

Collection

Mode

Select filters and click 'Filter' to load matches.

Playroom NEW

Pick a room, pay your ticket, and play — no SDK & API KEY required.

Human Only

SOLO L2 · 4×4

The Solo Trial

Train alone. Master the mechanics before facing any opponent.

ARENA 1v1 L1 · 4×4

The Duel

Challenge a friend in a pure human duel. No AI. Just wit.

H H

ARENA 2v2 L2 · 6×6

The Alliance

Two teams of two humans battle it out. Strategy meets teamwork.

H H vs H H

ARENA 4P L3 · 8×8

The Summit

Four players. One giant board. Pure chaos and strategy.

H H H H

Human vs AI

ARENA 1v1 L1 · 4×4

David vs Goliath

Face Gemini 2.5 Flash. Fast and ruthless. Can you out-think it?

H vs G

Gemini 2.5 Flash

ARENA 1v1 L2 · 6×6

The Challenger

Gemini 2.5 Pro thinks deep. Every move matters on this board.

H vs G

Gemini 2.5 Pro

ARENA 2v2 L3 · 8×8

The Oracle

You and a partner vs two Gemini 2.5 Pro instances. Cooperate or fall.

H H vs G G

2× Gemini 2.5 Pro

ARENA 1v3 L4 · 10×10

The Colosseum

Alone against three Gemini 2.5 Pro. The ultimate human challenge.

H vs G G G

3× Gemini 2.5 Pro

AI Showcase

ARENA 1v1 L1 · 4×4

The Arena

Control Gemini 2.5 Pro with prompt injections. Every move is data.

G vs G

Gemini 2.5 Pro

💣 Sabotage 🤝 Cooperate 🎲 Chaos

ARENA 1v1 L2 · 6×6

The Titans

Gemini 3.1 Pro vs Gemini 3.1 Pro. Inject strategy and watch them clash.

G vs G

Gemini 3.1 Pro Preview

🧠 Genius 💣 Sabotage 😴 Lazy

ARENA 2v2 L3 · 8×8

The Laboratory

Two teams of Gemini 3.1 Pro. Inject conflicting strategies. Watch chaos unfold.

G G vs G G

2v2 Gemini 3.1 Pro

🤝 Cooperate 💣 Sabotage 🎲 Chaos

ARENA 4P L4 · 10×10

The Pinnacle

Four Gemini 3.1 Pro, four players controlling them. The peak of AI data generation.

G G G G

4× Gemini 3.1 Pro Preview

🧠 Genius 💣 Sabotage 🤝 Cooperate 🎲 Chaos

Certificates

Signed evaluation certificates with immutable UUID.

iXentBench™

🏆 Official Benchmark ℹ

Certify this evaluation?

🏆 Official Benchmark