AitherOS Can Now Learn the Rules of Any World

Every AI system you've used operates on a script someone else wrote: prompts, rules, retrieval, fine-tunes. The thing we actually want is different — drop the system into a world it has never seen, and let it figure the world out. Watch what changes when it acts. Predict. Be wrong. Be surprised. Learn from exactly the places where its model of reality broke.

That capability — a self-bootstrapping world model — is now a first-class citizen of AitherOS. Not a research notebook: a served, versioned, gate-protected engine that three production systems already consume. This post is about what it is, what it can do today, and why it changes the shape of everything we build next.

The technology: predicting the world in latent space

The core is a JEPA — a joint-embedding predictive architecture in the LeCun lineage. Instead of generating pixels or tokens, the model encodes a state into a compact latent, and learns an action-conditioned predictor: given this latent and this action, what latent comes next? A regularizer keeps the representation from collapsing; an inverse-dynamics head makes the latent geometry action-aware; a decoder renders the model's imagination back to pixels so you can literally watch what it believes.

Prediction error is the magic. When the predicted next latent doesn't match reality, that gap is surprise — and surprise is the most useful scalar in machine learning. It's a novelty detector, an exploration bonus, an anomaly alarm, and a curriculum, all from one number the model computes about itself.

Our ARC-AGI world model is the flagship: a spatial encoder over full 64×64 game boards, per-token latents so a local action has a local effect, click coordinates fed as spatial planes, per-game conditioning, and a CEM planner that searches action sequences entirely in latent space — imagining futures without touching the real environment. It has banked over 170,000 training steps of continuous online learning and serves encode / predict / surprise / plan / dream as a persistent fleet service, GPU-budgeted to coexist with the rest of the platform.

And as of this week it carries a value head: alongside "what happens next," the model estimates how good a state is — discounted future return, trained on real reward traces. Planning now blends three signals: curiosity (seek novelty), dynamics (predict consequences), and value (reach toward wins, steer away from cliffs). That's the full RL triad, on top of a representation learned without labels.

One API for every world

The breakthrough of this program isn't any single model — it's the unification. Everything now lives in one canonical world-model package with one contract: observe / encode / predict / surprise / plan / train_step. Two engine lineages implement it — the spatial JEPA for grid worlds, and a fast tabular→neural transition engine for symbolic domains — and environment adapters turn anything into a stream of (state, action, next_state) transitions.

The serving layer grew a domain plane: the same service that speaks ARC grids now accepts descriptor states for any registered domain. A code-world adapter turns codebase structure — call graphs, landmarks, chunk semantics — into transition streams via signed feature hashing, so an edit to a function is an action whose consequences the model learns. A sandbox adapter does the same for agent environments. Transitions are journaled durably; the model's understanding of a domain compounds across restarts, forever.

The contract is scrupulously honest: a domain the model hasn't learned yet returns null surprise, never a confident guess. Cold start looks like cold start. Consumers decide what ignorance means for them.

What it's doing in production, today

Code search that knows where you're wrong. Our landmark ranker and codegraph hybrid query now carry a world-model re-ranking seam: results the model finds surprising get boosted, because surprise marks the exact places where the codebase diverges from the mental model — which is precisely what a search should surface. Live-proven end-to-end: the surprise boost visibly reorders results.

Evolution that schedules its own curriculum. The AitherEvolution loop now reads per-domain surprise directly from the world model and decides explore-vs-exploit like a scientist: unexplored domains first, then whatever the model finds most confusing; exploit the best-understood domain when everything is calm. Training-data harvesting reorders its curriculum by the same signal. The system literally studies what it doesn't understand yet.

Agents that learn safely before they act. The aither-adk toolkit gained a world_model pack: any agent can observe transitions, query surprise, and run a curiosity-driven explore loop inside a sandbox — with tool readiness gated on the model's demonstrated understanding. An agent proves it has learned an environment's rules (surprise driven measurably down over episodes) before it's trusted to operate there. In our deterministic sandbox proof, revisited transitions stop being surprising within a handful of episodes — visible, quantified learning.

Models that write their own training data. We wired SEAL — self-adapting language models — into the training plane end-to-end. The loop: take new knowledge, have the model generate its own self-edits (restatements, implications, question-answer pairs), fine-tune a throwaway LoRA adapter on them, and keep or discard the edit based on whether the adapted model genuinely answers held-out questions better than baseline. Generation runs through the fleet's own inference scheduler; training runs on our GPU trainer; evaluation runs against the actual trained artifact. The full reset-train-infer-verdict cycle executes autonomously, small-scale local today, with an idle-window scheduler that runs it whenever the GPU frees up — and a scale-up path already wired for larger models and rented compute behind a cost gate.

Research velocity with production safety. The engine doubles as an experiment platform: C-JEPA object-level masking (from the counterfactual- reasoning literature) and a neuromorphic-inspired homeostatic learning-rate controller — surprise-modulated plasticity with variance-band regulation — are both implemented behind flags, with a promotion gate that A/Bs any candidate against the champion on identical held-out data. Experiments that don't beat the champion stay off; the ones that do will ship themselves. The whole model line is pinned by a golden-checkpoint parity gate across all three trees that serve it, so every change proves its default behavior is bit-stable before it lands.

The flywheel

Put the pieces in one frame and the shape is obvious:

1. Explore — agents and solvers act in their worlds; every transition flows into the domain plane.
2. Learn — the models train continuously, online, journaled, compounding.
3. Measure — surprise quantifies exactly where understanding is thin.
4. Schedule — evolution points training and exploration at the thin spots.
5. Self-edit — SEAL turns new knowledge into weight updates that must prove they help.
6. Repeat, forever, unattended.

That's not a feature. That's a metabolism.

Where this goes

Any-environment enrollment. The adapter contract is deliberately tiny: observe, act, step. Next is env_enroll — hand the system a new environment (a web app, a game, an API, a filesystem) and let it derive the adapter, explore under a safety budget, and report back with a learned model of the rules. The cursor-world sandbox already proves the loop; the roadmap is pointing it at everything AitherOS touches.

The crowd-sourced world model. Our ARC contribution gateway already accepts transitions from external players and agents — authenticated, rate-limited, quarantined, trust-scored. Human play and agent play feed the same replay stream. The endgame: a world model trained by everyone who plays, where every game anyone finishes makes the shared model of how these worlds work a little sharper. ARC-AGI-3 is the proving ground; the mechanism is general.

Value-guided everything. With the value head merged, latent-space planning stops being merely curious and starts being ambitious — plans scored by predicted long-horizon return, not just novelty. The same machinery generalizes to any domain with a reward signal: deployment outcomes, task success, user satisfaction.

Self-improvement at model scale. SEAL's next runs climb the model-size ladder on idle fleet GPUs. The destination is a platform where "the system learned something new" routinely means the weights changed — proposed by the model, validated by held-out evaluation, gated exactly like any other deploy.

The self-describing OS. AitherOS's north star is an operating system that can explain and regenerate itself. A world model of the OS's own domains — its code, its fleet, its behaviors — is the missing organ: the part that notices when reality diverges from the model, and knows precisely what to relearn.

Why this matters

Prompted intelligence is ceiling-limited by what you thought to write down. World-model intelligence is ceiling-limited by what the system can experience — and experience scales with every environment you connect, every agent you run, every player who shows up.

AitherOS now has the machinery to be surprised, and the machinery to do something about it. Everything else we're building this year stands on top of that.