Two Levers

SIA × GraphWorldModels A self-improving AI loop where every improvement is measured against reality. The problem A deployed AI agent performs at some level and then stays there. Improving it usually takes a human in the loop — someone notices it's underperforming, diagnoses why, hand-edits the prompt or scaffolding, or kicks off a retraining job. That cycle is slow, expensive, and doesn't scale. The agent can't get better on its own from its own experience. For an agent to improve itself safely, two things have to be true: it needs to act on both levers that actually move performance — the scaffolding around the model and the model's own weights — and every gain has to be a real, verified number, because you can't responsibly let a system modify itself on a metric you don't trust. What this is A working implementation of the two-lever self-improvement loop from the SIA paper, built on a real world model from the GraphWorldModels project. An agent is dropped into an environment it knows nothing about and improves itself with no human in the loop: It builds its own world model. By exploring, the agent learns how its environment behaves — which moves from which states lead where, and what they're worth — and stores it as a real transition graph (the GraphWorldModels Neo4j schema). It plans over this map instead of acting blindly. You watch the value landscape light up live as it learns. Lever one — it fixes its own scaffolding. A Feedback-Agent reads the agent's actual performance (success rate, coverage, whether it's plateaued) and rewrites how the agent operates — its exploration, its planning depth — when it's underperforming. In the demo you watch it detect that the agent is stuck and fix it, with the performance curve responding. Lever two — it retrains its own weights. When better scaffolding stops paying off, it fine-tunes the underlying language model on the agent's own logged experience, using real GRPO LoRA — the method and structure from the SIA repo (8-sample groups, advantage = reward minus group mean), running on a GPU. Every number on screen is computed from real outcomes — path efficiency is literally optimal-steps over actual-steps, graded by the environment. Nothing is hardcoded to a target; delete the loop and the dashboard goes blank. What it proves A complete self-improvement loop — a world model the agent builds, a feedback agent that fixes the scaffold, weight updates that retrain the model — that closes and stays measurable, with every improvement earned from real outcomes. The demo runs this loop live. Why it matters The same shape — a world model the system builds, a measured feedback loop that improves the scaffold, selective weight updates, all verified against reality — is the pattern behind real deployed agents that today only improve when a human intervenes: a trading agent that should sharpen its edge from realized outcomes, a drone that should improve its navigation from flight logs, an analytics agent that updates its model as new data arrives. The grid is the cheapest environment to prove the loop itself works and is measurable; swap in the real domain and the machinery is identical. The honest boundary: this proves the loop is real and measurable — not that it already beats a hand-tuned production system on a real task. The demonstration is the mechanism; the application is that same measured pattern, pointed at a real environment.

Team

Placement

Participant