SCHEMA: Making AI Agents Think Like Physicists — A Programmatic World Model Harness

Forum topic · ✨步子哥 · 2026-07-19

Summary

SCHEMA is an execution framework (harness) for frontier AI agents, built around a programmatic world model: rather than updating model weights, it changes the process around them. Presented as a one-page academic-style poster for the zhichai.net forum, it targets ARC-AGI-3 (25 public games, RHAE metric). The framework decomposes the problem into two jointly solved levels: state grounding (mapping raw 64x64 pixels to objects, attributes, and relations) and mechanism discovery (inferring an executable step() transition program from state-action-next-state triples). Both are co-encoded in a single editable program, so counterexamples can falsify either the rules or the state representation itself. SCHEMA runs a dual loop: an outer loop (observe, deliberate, execute, record to an append-only timeline) drives game progress, while an inner loop (theorize, certify via backtesting, plan with zero-cost BFS, commit actions) enables free trial-and-error inside the model. Its philosophical anchor is Einstein over Lorentz: when predictions systematically fail, redefine the state itself instead of patching rules. The poster claims substantial performance gains over the raw model on the same frontier LLM.

Overview

SCHEMA — The Principle of Patterns: Making Agents Think Like Physicists

SCHEMA is an *execution framework* (harness) centered on a programmatic world model. Its tagline: it changes not the model's weights, but the process around it — the same frontier model is transformed when given this harness. Evaluation context: ARC-AGI-3 public set, 25 games, RHAE metric, 2026.

Core idea (pull quote):

> A *pattern* (schema) is a *rule of construction*. It connects abstract concepts (theories, mechanisms, predicates) to concrete percepts (pixels, trajectories, counterexamples) through a human-readable, verifiable, searchable *program* — letting the agent move back and forth between perception and concepts, like a physicist at the lab bench.

§ 1 · Problem Decomposition and Loop Architecture

Two abstract levels, solved jointly — state grounding and mechanism discovery are inseparable: when rules fail, the bug may lie in the state representation, not the law itself.

Level 1 · State grounding — observation → state program. Identify objects, attributes, and relations from raw pixels. Prior work: VIGA (analysis–synthesis loop).
Level 2 · Mechanism discovery — (s, a, s′) → step(). Learn how state changes with actions as an executable program. Prior work: WorldCoder (transfer learning, but requires structured input).
SCHEMA's innovation: co-encode both levels in one editable program, so counterexamples can indict either the rules or the state itself.

Dual loop (8 steps total):

Outer loop (drives the game): OBSERVE (64×64 pixels) → DELIBERATE → EXECUTE (compare against prediction) → RECORD (append-only Timeline).
Inner loop (one deliberation cycle, free simulation): THEORIZE (write step()) → CERTIFY (backtest) → PLAN (BFS, zero cost) → COMMIT (commit_actions).

Every step is traceable, replayable, and backtestable; the inner loop permits trial-and-error *inside the model* at no real-world cost.

§ 2 · Philosophical Anchor: Lorentz vs. Einstein

Route A (Lorentz) — keep the ether: when observations contradict theory, patch the existing framework with compensating terms (e.g., contraction hypotheses); state unchanged, only parameters adjusted.
Route B (Einstein) — discard the ether: demote "simultaneity" from an absolute basis to a relative frame, and elegant electrodynamics of moving bodies emerges.

SCHEMA follows Einstein's path: when hypotheses systematically fail, redefine the *state itself* — predicates like is_goal must be inferred from interaction.

§ 3 · Three Iron Rules

The poster's third section enumerates three governing principles (color-coded gold/teal/rose in the original design). Details are truncated in the source, but consistent with the framework's stated logic: joint encoding of state and mechanism, verifiable programs, and simulated planning before committing actions.

Takeaway

SCHEMA argues that *how you use* a frontier model matters more than the model itself: a programmatic, falsifiable world model with a dual-loop harness lets an agent behave like a physicist — theorizing, testing against reality, and revising even its ontology when evidence demands it.