Building a Chess-Native Reasoning Architecture

Turn the scaffold into a set of falsifiable components, not a larger prompt

The easiest response to a weak chess-playing language model is to give it more chess text, more tools, more reflection, and more tokens.

Our pilot points in a less comfortable direction. The model may not need more of everything. It may need a different division of labor.

In the frozen Luna study, the unaided system's joint local rating was estimated near 1067. With two randomized, unranked Stockfish proposals, the combined system was estimated near 2832. The profile intervals were wide—705–1351 and 2680–2992—and the games were exploratory, Black-only, and protocol-specific. Even with those qualifications, the system effect was too large to dismiss.

The shape was more informative than the point estimates. Ten proposals barely helped Luna, while two and three helped dramatically. DeepSeek V4 Flash then showed another boundary: its first top-2 anchor finished 10–0 against Stockfish 1320, but high-reasoning full-game play accumulated tens of millions of tokens and more than one hundred worker-hours while the ladder was still unsettled. Its regular anchor also mixed chess losses with wrong-action forfeits.

These are observations about two harnessed systems. They do not establish that either model contains a grandmaster critic, that two candidates are universally optimal, or that a particular architecture will work.

They do motivate an architecture program with a precise objective:

Externalize one operation at a time, measure the repair, identify the minimum sufficient interface, and internalize only the operations that survive controlled tests.

The result should be chess-native without becoming “Stockfish with an LLM attached.” Its purpose is to discover which reasoning operations a language model can perform, which should be deterministic, and which should be learned as separate modules.

Three evidence levels

Architecture work becomes unserious when an exploratory result turns directly into a design diagram. We therefore separate three levels of claim.

Observed system results

• Candidate assistance changed Luna's full-game outcomes substantially.
• The exploratory candidate-count curve was non-monotonic.
• Luna top-2 and top-3 were far stronger than regular and top-10 under the local protocol.
• DeepSeek's high-reasoning agent consumed very large completion-side token and worker-time budgets.
• DeepSeek regular play produced both checkmate losses and action-protocol forfeits, despite no provider-error games in the recorded anchor.
• In the frozen Luna replay, the conversational parser selected a legal move directly on 49.6% of 27,218 retained black-response attempts, while the deterministic legal-action compiler selected one on 88.8%. This 39.2-point difference is descriptive: attempts are clustered within games and runs, so it is not accompanied by an independence-based confidence interval.
• In a separate, deliberately outcome-stratified 323-case challenge sample, the compiler recovered 100 direct legal selections rejected by the conversational parser and lost none accepted by it. That sample diagnoses a recoverable interface failure; its bootstrap interval and exact paired test must not be read as population-prevalence estimates.

Mechanism hypotheses

• The unaided policy may fail to propose moves that the model can recognize once shown.
• A wide shortlist may overload comparison, attention, or branch control.
• Explicit successor states or opponent replies may repair internal transition errors.
• Compact state and constrained action interfaces may remove non-chess failure.
• Uncertainty-gated compute may preserve strength with fewer tokens.

Architecture proposals

• deterministic state and legal-action layers;
• a compact proposal policy;
• an explicit branch executor;
• a comparative, calibrated value model;
• an uncertainty and budget controller;
• a compact trajectory memory; and
• a legal action compiler plus complete telemetry.

The full-game system effects and the frozen interface replay are established at their stated evidence levels. The replay establishes parser/interface recovery, not native constrained decoding, move quality, or Elo. The remaining mechanism hypotheses have preregistered paired tests but no confirmatory result yet. The architecture remains a contingent engineering plan.

The architecture in one picture

Figure — Executable chess-native control flow

Figure 1. The control flow implemented today in research/architecture/protocol.py. Each green event badge names a provider-free structural event. Illegal or duplicate proposals are rejected before valuation, an empty accepted set receives a visible deterministic legal fallback, and the uncertainty gate may request at most one expanded round. The material evaluator and lexicographic proposer are weak controls—not learned chess modules or evidence of playing strength.

The executable control is deliberately narrower than the proposed end-state architecture below. In particular, it does not yet contain learned proposal or calibrated WDL modules, explicit reply search, or compact trajectory memory.

authoritative game state
        │
        ▼
state packet + legal-action mask
        │
        ▼
proposal policy ───────► adaptive support controller
        │                         │
        ▼                         │ widen / narrow / stop
explicit branch executor ◄───────┘
        │
        ▼
comparative WDL critic
        │
        ▼
decision + calibrated uncertainty
        │
        ▼
legal action compiler
        │
        ▼
board transition + compact memory update

Every arrow emits a machine-readable record. That is not an implementation detail. If the proposal set, branches, values, uncertainty, and final action are not preserved separately, the architecture cannot explain its own success.

The contracts in this diagram now have a runnable control implementation in research/architecture/protocol.py. It replays history into a deterministic state identity, masks legal actions, filters bad proposals, evaluates successors with an intentionally weak material baseline, performs one bounded uncertainty escalation, and emits provider-free structural telemetry. The control is not evidence for the architecture's chess strength; it proves that future learned or model-backed modules can be swapped and tested without changing the surrounding scientific contract.

1. Authoritative state, not conversational reconstruction

The board should live outside the language model as a deterministic object.

The state layer owns:

• piece locations and side to move;
• castling and en-passant rights;
• half-move and full-move clocks;
• repetition history;
• legal actions;
• terminal-state detection; and
• a reproducible state hash.

The model receives a versioned StatePacket, not an accreting transcript that it must reinterpret from scratch:

StatePacket {
  fen,
  side_to_move,
  legal_moves,
  repetition_count,
  recent_moves,
  state_hash
}

This layer is justified first by reliability, not by a demonstrated grounding mechanism. In the DeepSeek regular anchor, four of eight losses ended through wrong-action exhaustion rather than checkmate. The end-to-end system should count those losses. A chess-quality analysis should also be able to distinguish them from poor evaluation.

Hypothesis: authoritative state plus constrained legal-action output reduces protocol failures and board-state inconsistency without weakening legal move quality.

Falsifier: on identical positions, the structured state and action mask do not reduce illegal/wrong-action events, or they reduce them while WDL regret on otherwise legal moves worsens enough to offset the gain.

The first provider-free control now isolates the action-interface half of this hypothesis. Every retained Luna response was replayed through both the historical conversational parser and a deterministic legal-action compiler using the exact reconstructed position. Across the full eligible corpus, direct legal-action selection rose from 0.496 to 0.888. The compiler used no model calls and changed no source evidence. This is strong evidence that a substantial fraction of observed action failure is recoverable from already-retained output, but it does not test whether token-level masking changes what the model generates or whether the recovered moves are good. Those are the prospective follow-ups.

Figure — Frozen A100 interface-recovery result

Figure 2. Panel A reports descriptive attempt-level rates across the complete 27,218-attempt eligible replay corpus; attempts cluster within games and runs. Panel B reports the paired contingency in the deliberately outcome-stratified 323-case challenge set. The zero “parser only” count is a replay property of this frozen sample, not a population-prevalence or move-quality claim.

The first prospective follow-up is now complete without spending another model token. A deterministic mock policy supplied a known legal target across 256 reachable states and nine deliberately frozen response surfaces. The full 2,304-pair matrix is a systems test, not a sample from model traffic. Direct target fidelity rose from 0.222 under the conversational parser to 0.778 under the constrained compiler, and legal execution rose from 0.333 to 1.000. The compiler retained every canonical target and gained on five noncanonical surfaces.

The control also found the boundary we needed it to find. When a response first issued a legal command and then explicitly revised its final move, the compiler preserved the first command in all 256 cases. That behavior was intentional in A100 because it protected accepted historical actions, but it is not a general solution to semantic revision. We therefore promote native constrained-output design while withholding any production change from first-command to last-answer precedence until natural held-out responses resolve the tradeoff. Fallback-only legality remains safety completion, never recovered intent.

Figure — A101 response-surface matrix

Figure 3. Exact outcomes across the constructed 256-state × 9-surface A101 matrix. Separating direct target fidelity from legal execution makes the two critical boundaries visible: fallback can complete a legal action without recovering intent, and accepting a legal command can preserve the wrong choice after an explicit revision. These are systems-test rates, not estimates of natural response prevalence.

The preregistered natural-output follow-up did not resolve that boundary—and that negative result matters. A102 verified every member of the frozen Luna source set and censused all 27,218 A100-eligible parser-visible attempts using a locked definition: a production-reachable legal command, followed by an explicit revision cue, followed by one unambiguous different legal move. Zero attempts qualified. The exact exclusion census was 13,657 responses masked by a non-move action, 13,503 legal commands with no later revision cue, 35 without a first command, and 23 with an illegal first command.

This is not evidence that revisions never occur, nor support for preserving the first command. It says this particular frozen traffic contains no natural paired signal under the preregistered rule. We keep the production precedence unchanged, publish the empty paired event files instead of manufacturing cases, and require a prospective natural or semisynthetic known-intent collection before reopening the parser gate.

The next provider-free control moved from parsing into the proposal boundary. A110A's internal chronology records its protocol before outcome extraction, then the replay reverified all 287 frozen Luna files. It included 12,791 response attempts whose last visible prompt contained one valid unranked candidate block and paired the all-legal compiler with a compiler restricted to those displayed moves. Of 11,002 direct all-legal selections, all 11,002 were inside the displayed set: a zero conditional hard-mask intervention rate with a game-cluster interval of 0.000–0.000. That is not zero intervention overall. The other 1,789 pairs used an explicit system fallback in both arms, and different fallback choices made 1,345 of 12,791 paired outputs differ.

Review then exposed the immediate-prompt scope as too narrow. A separate, explicitly post-hoc sensitivity attached the unique original candidate block only when frozen game path and source ply both matched. All 25,247 attempts from candidate runs mapped, with zero conflicting keys and zero unmapped follow-ups. Among 23,353 open-direct actions, 23,332 were inside the attached set and 21 were outside: membership 0.999100758 and conditional intervention 0.000899242. The per-variant inside/total counts were 974/974 for top-10, 5,879/5,886 for top-2, 9,424/9,433 for top-3, and 7,055/7,060 for top-5. Actual displayed-set size strata are published in the frozen analysis rather than inferred from the configured maximum.

A content-addressed post-hoc census then traced all 21 exceptions back to the raw transcript bytes. All 21 were accepted make_move commands, not loose UCI token recoveries. Twenty followed a same-position board display and one followed a legal-move list; 20 occurred on the second attempt at the position and one on the third. In every case, the original candidate-bearing response had asked for a tool view before embedding an in-set command, after which the model issued a different legal command outside the set. This is descriptive evidence of tool-mediated revision, not evidence that the revision was better, that the candidate set was deficient, or that either proposer or selector caused the change.

Figure — A110A proposal-boundary primary and sensitivity

Figure 4. Panel A makes the extraction boundary visible: the locked primary uses immediate candidate-header responses, while the explicitly post-hoc sensitivity attaches the unique original block to same-position follow-ups by exact game path and source ply. Panel B plots outside-set direct actions per 10,000 so near-total membership does not hide the 21 exceptions. Panel C keeps the conditional direct-action intervention endpoint separate from all-pair output changes caused by different fallback sets. This is shared-precedence membership evidence—not independent selector quality, move quality, causal benefit, or Elo. The artifact hashes do not independently prove preregistration timing.

These are boundary checks, not chess-strength results. They say candidate membership was extremely high under the same parser precedence in both arms; they do not independently test selector quality, say the candidates were good, identify the best candidate, or show that assistance caused stronger play. The locked primary still excludes the 12,456 tool follow-ups; the post-hoc artifact, not the primary, supplies the same-position sensitivity. A prospective held-out A110 proposer/selector cross is permitted, while production behavior remains unchanged. Finally, because these files are untracked and have no external timestamp authority, their hashes bind the current protocol to the outputs but do not independently prove the before-outcome ordering; that ordering remains an internal chronology claim.

The test must compare equivalent information renderings—FEN, board, piece list, structured state, and compact state plus recent moves—not silently give one condition more chess knowledge.

2. A compact policy should propose, not decide

The proposer answers one question: which legal moves deserve downstream analysis?

Its output is a distribution or shortlist with provenance:

ProposalSet {
  moves: [{uci, policy_mass, source}],
  omitted_mass,
  proposal_budget,
  state_hash
}

In research conditions, source may be model, compact learned policy, engine oracle, or random legal control. Engine scores and ranks remain hidden from the selector unless they are the named intervention.

The Luna top-2 result is consistent with a proposal bottleneck because supplying strong moves produced a large repair. It does not prove one. The shortlist also reduced branching, supplied notation, and carried an authority label. Worse, the pilot's top-2 and top-10 sets came from separate wall-clock MultiPV searches and were not guaranteed to be nested.

The proposer–selector cross is therefore the first gate:

Proposer	Selector	Diagnostic question
Model	Model	Can the unaided pipeline act well?
Model	Engine	Did the model's support contain a good move?
Engine	Model	Can the model exploit strong proposals?
Random legal	Model	Can it reject distractors?
Engine	Engine	What is the harness ceiling?

Hypothesis: the model's self-generated support has lower near-optimal-move coverage than an oracle support that the same model selects well.

Falsifier: self-generated shortlists already contain near-optimal moves at a high rate, but model selection rejects them; or nested oracle top-2 fails to improve paired move regret over naked play.

If falsified, building a better policy module attacks the wrong component.

3. Branches should be executed, not narrated

A move name is not a successor state. The transition layer applies candidate moves to the authoritative board and can expose controlled amounts of reply information.

BranchRecord {
  root_state_hash,
  candidate_move,
  successor_fen,
  opponent_reply?,
  continuation?,
  branch_budget
}

The architecture begins with one-ply deterministic transitions. Deeper branches are added only under a registered compute budget. The value model never has to guess where pieces moved merely because notation was terse.

This component targets a search/transition hypothesis, not an observed defect. The present full-game ladder cannot tell whether Luna succeeded with top-2 because it calculated the candidates, recognized familiar moves, or followed a prior.

The decisive experiment presents the same candidate set in stages:

1. move notation only;
2. successor state after each candidate;
3. successor state plus the opponent's best reply; and
4. a short, engine-verified principal variation.

Hypothesis: externalized transitions reduce WDL regret, especially in tactical positions and delayed-refutation cases.

Falsifier: successor states and replies do not improve matched choices, or improvements vanish when notation, token length, and candidate order are controlled.

If one-ply successors repair performance but principal variations add little, the model may be a useful evaluator with weak state transition. If deep lines still end in misranking, value—not search—becomes the target.

4. The critic must output calibrated value, not persuasive prose

The critic compares fully specified successors and returns an outcome distribution from the relevant player's perspective:

ValueRecord {
  branch_id,
  win_probability,
  draw_probability,
  loss_probability,
  confidence,
  value_model_version
}

Pairwise comparison may be easier than assigning absolute probabilities, so the research implementation should support both. Listwise values must be checked for transitivity; probabilities must be checked for calibration.

The phrase “Luna is a strong critic” remains a hypothesis. Top-2 assistance shows that the combined pipeline can exploit a tiny oracle set over full games. It does not isolate value from search, state, presentation, or policy priors.

Hypothesis: when transition burden is removed, the model ranks strong successor states substantially better than its unaided move policy would imply.

Falsifier: it misranks fully specified successors, remains poorly calibrated on held-out positions, or changes preferences under equivalent color/notation transformations.

A critic that produces elegant analysis but poor WDL calibration is not a value function. The architecture must optimize predictive quality rather than prose quality.

5. The controller spends search where information is valuable

Fixed top-2 is a condition, not a general controller.

Sometimes one legal move dominates. Sometimes several moves are equivalent. Sometimes a plausible move fails only after a deep reply. A fixed shortlist and fixed reasoning budget ignore all three cases.

The controller observes policy concentration, critic margins, disagreement, and remaining budget. It chooses among actions such as:

• accept the current leader;
• compare the top two again under a different prompt/order;
• widen support;
• request opponent replies;
• deepen one branch;
• call a stronger verifier; or
• stop and compile the move.

ControllerState {
  policy_entropy,
  value_margin,
  evaluator_disagreement,
  tokens_used,
  latency_used,
  remaining_budget
}

DeepSeek supplies the operational motivation. At the dated provisional 2026-08-04T21:10:33Z efficiency snapshot, 43 clean games had recorded 24.43 million tokens and 157.55 worker-hours. More than 91% were completion-side tokens. These are harness-level measurements, not intrinsic provider throughput, but they demonstrate that unbounded high reasoning can dominate the experiment even when token prices are low.

Hypothesis: uncertainty-gated search matches fixed high-reasoning move quality with lower tokens and latency.

Falsifier: controller uncertainty fails to predict regret, adaptive compute reduces cost only by weakening hard-position performance, or a fixed small budget dominates the adaptive policy on the held-out strength–cost frontier.

The controller itself must be cheap. Spending a full model call to decide whether to spend a full model call can erase the gain.

6. Memory should preserve state and plans, not raw conversation

Full games matter because the player inherits the consequences of its own moves. Yet a growing transcript bundles useful trajectory information with irrelevant verbosity.

The memory layer should separate:

• authoritative board state;
• recent tactical sequence;
• repetition and draw state;
• compact strategic commitments;
• unresolved threats; and
• provenance of every remembered claim.

Plans are hypotheses, not facts. They should expire when the position hash or evaluation changes sufficiently.

The current pilot cannot establish context degradation. It started every game from move one, so late positions are also harder positions reached after different earlier choices. The causal test resumes the same FEN under fresh context, full exact history, compact reconstructed state, and irrelevant length-matched history.

Hypothesis: compact state plus recent relevant trajectory preserves or improves move quality while reducing tokens relative to full conversation.

Falsifier: exact history outperforms compact memory after position difficulty is paired, or all history conditions perform equivalently.

If irrelevant length-matched history hurts, attention load is implicated. If only exact history helps, the architecture is discarding useful trajectory information.

7. The action compiler makes reliability measurable

Analysis and action emission should be separate interfaces.

The model may reason freely inside a bounded call, but the final component accepts only a legal move from the current state's mask. If the model fails to produce one, the event is recorded as an interface failure under the frozen fallback policy. It is never silently repaired and then credited as model success.

This design has two benefits:

1. deployed games avoid wasting repeated conversational turns on syntax; and
2. research can publish both end-to-end system score and conditional chess quality among valid actions.

Hypothesis: constrained action compilation removes a material fraction of wrong-action losses with negligible effect on chess regret.

Falsifier: failures migrate into confidently legal but poor moves, leaving end-to-end score unchanged; or constrained output changes the reasoning process enough to worsen matched decisions.

The compiler is not permission to erase interface weakness. Both pre-compiler and deployed-system results remain visible.

8. Telemetry is part of the architecture

Every decision should emit a DecisionRecord linking:

• state and prompt hashes;
• proposal set and hidden source ranks;
• candidate presentation order;
• executed branches;
• value outputs and uncertainty;
• controller actions and budgets;
• selected move and legality;
• tokens, latency, retries, and request IDs;
• returned model/provider identity; and
• post-move engine regret computed choice-blind under a declared evaluator.

The existing research/instrumentation/ layer already defines candidate caches, an event ledger, deterministic schedules, and request telemetry for the paired study. The architecture should consume those contracts rather than invent a second, opaque logging path.

Observability is what converts a stronger player into a scientific instrument.

A staged program, with gates

Building every module at once would recreate the original ambiguity in cleaner code. The program therefore advances only when a component earns its place.

Stage 0 — Freeze the baseline

Inputs: completed Luna evidence, ongoing DeepSeek evidence, exact prompts, raw games, token ledger, corrections, and code hashes.

Gate: every headline regenerates from frozen artifacts; exploratory and provisional cohorts remain labeled.

Stage 1 — Diagnose policy and comparison

Run preregistered E020/E021 on identical positions with naked, self-shortlist, nested oracle top-2/top-5/top-10, and best-omitted conditions.

Primary endpoints: WDL regret and catastrophic-blunder rate.

Gate: add a learned proposal module only if policy coverage explains a meaningful share of oracle repair on held-out positions. Add an adaptive-width controller only if the nested top-10 penalty survives value-gap and order controls.

Stage 2 — Diagnose transition and value

On a frozen subset, add successor states, opponent replies, and short principal variations. Separately rank successor positions without revealing originating move labels.

Gate: add a branch executor if explicit transitions repair selection. Train or adapt a critic only if ranking/calibration remains the limiting component after transitions are supplied.

Stage 3 — Prototype modules offline

Train or configure each component against frozen training positions. Hold out entire opening families, tactical motifs, and source games.

Gate: improvements must survive held-out regret, calibration, color reversal, notation equivalence, and adversarial distractors. No component is promoted for matching training-engine labels alone.

Stage 4 — Integrate under a fixed budget

Compare the modular system against the original conversational harness under matched model, total token ceiling, engine-node ceiling, and wall-time policy.

Gate: the system must improve the joint frontier—not just Elo, and not just cost. Publish strength, WDL regret, protocol failures, tokens, latency, engine nodes, and dollars together.

Stage 5 — Return to complete games

Use a frozen opening suite, both colors, deterministic fixed-node advisor data, a separately declared choice-blind adjudicator with evaluator-family sensitivity, and interleaved conditions. Full games test whether local repairs survive trajectory feedback.

Gate: paired-position gains must predict complete-game gains. If they do not, the missing component is trajectory control, not local move selection.

Stage 6 — Distill only validated scaffolds

Once a component passes causal and full-game gates, convert its traces into supervision:

• proposal coverage for a compact legal-move policy;
• successor comparisons for a calibrated value adapter;
• delayed refutations for branch allocation;
• confidence versus regret for the controller; and
• compact state/history pairs for memory.

Gate: a distilled component must retain gains without access to the oracle signal at inference and must generalize to held-out openings and motifs.

Training without laundering the oracle

Engine assistance creates a leakage risk. A system can appear to have learned reasoning while merely reproducing cached engine preferences.

The training protocol should therefore:

• split by source game and opening family before generating labels;
• keep confirmatory positions permanently out of training;
• use a separately declared choice-blind evaluator and test a different engine family or network before claiming evaluator independence;
• evaluate moves whose best action differs from common opening priors;
• test color reversal and equivalent board encodings;
• withhold source ranks and scores from the deployed selector; and
• report engine calls at both training and inference.

The goal is not to hide that an engine supplied supervision. The goal is to show exactly which externally supplied operation became an internal, generalizing capability.

Three candidate systems

The architecture program should produce increasingly ambitious baselines.

System A — Reliable conversational player

• authoritative state;
• legal action compiler;
• original model reasoning;
• complete request telemetry.

This isolates how much performance is lost to interface and state mechanics.

System B — Adaptive scaffolded selector

• all of System A;
• cached proposal policy;
• deterministic successor execution;
• uncertainty-gated widening and reply search;
• comparative value calls.

This tests the best externalized architecture under an explicit resource budget.

System C — Distilled chess reasoner

• compact learned policy over legal moves;
• calibrated value adapter;
• learned compute controller;
• symbolic state and transition core;
• no Stockfish proposals or scores at inference.

This is the first system that can claim to have internalized part of the scaffold. It remains a hybrid agent, not an unaided language model.

Success is a vector

The final comparison should not collapse immediately into one Elo number.

Dimension	Required measure
End-to-end strength	Raw W–D–L, joint local rating, uncertainty
Local decision quality	WDL regret, catastrophic blunders
Policy	Near-optimal coverage, omitted mass, diversity
Value	Pairwise accuracy, calibration, transitivity
Search	Repair from successors/replies, branch efficiency
Reliability	Legal-action and protocol-failure rates
Trajectory	First-failure hazard, recovery, censoring sensitivity
Compute	Tokens, requests, engine nodes, wall time, worker-hours
Dollars	Reconciled request-level billed cost

A component is valuable if it moves the system's Pareto frontier on held-out data. A stronger but ten-times-slower player may be useful for research and useless for deployment. A cheaper player that wins only by exploiting one opening funnel is not a general architecture improvement.

What would make us abandon the architecture?

The modular thesis weakens if the paired studies show that none of the proposed interfaces predicts the full-game effect. It weakens if the model's performance depends on holistic conversational reasoning that deteriorates when policy, transition, and value are separated. It fails as an efficiency program if module orchestration consumes more tokens and latency than the original agent at matched strength.

The “externalize then distill” strategy fails if gains disappear without live engine proposals, remain confined to training-like positions, or collapse under provider/model changes. In that case, the engine is the player and the model is only a fragile interface.

These are acceptable outcomes. The purpose of the architecture is not to prove that LLMs secretly play grandmaster chess. It is to locate a useful division of labor—or demonstrate that one does not exist.

From chess agent to reasoning architecture

Chess is unusually clean: legal actions are enumerable, transitions are exact, strong evaluators exist, and errors persist into a complete trajectory. The same architecture questions recur in coding, theorem proving, planning, and research agents.

A coding model may review a strong patch better than it can propose one. A planner may recognize a good plan but fail to expand the right branch. A research agent may collect useful hypotheses and then compare too many of them poorly. In each case, “use a bigger prompt” leaves proposal, transition, value, memory, and compute allocation entangled.

The chess-native architecture is valuable even if it remains a laboratory instrument. It forces every claimed reasoning capability to cross a boundary, emit evidence, and survive a falsifier.

We should not build a grandmaster-shaped prompt.

We should build a system that tells us which part learned to think.

---

Reproducibility and evidence note

The Luna ratings cited here come from the frozen exploratory pilot and joint Davidson W-D-L analysis. They are Black-only, Stockfish-18 anchored, and local to the recorded protocol. DeepSeek results are provisional snapshots and are not converted from saturated scores into finite Elo.

E020/E021 is preregistered before paid diagnostic observations. Its 600-position paired design uses cached fixed-node max-10 analysis, strictly nested prefixes, two total presentation orders on the 200 ambiguous positions, both sides to move, explicit failure handling, and position-clustered inference. Four or more orders belong to a separate order-focused experiment or versioned extension. Candidate construction, event schemas, deterministic scheduling, and request telemetry live under research/instrumentation/. Architecture gates will be updated only through the decision and claims ledgers; negative results and abandoned modules remain part of the public record.