Gradient planning routes through the measured pathway

A planner is only as good as the gradient it trusts

GRASP, a gradient-based planner for learned world models from BAIR Berkeley, reaches 26.2% success at horizon 60 on the Push-T benchmark where vanilla gradient descent manages 16.4% — and it does so by refusing to optimize through the one pathway every differentiable simulator offers by default: the brittle state-input gradient. The work, published in April 2026 as "Gradient-based Planning for World Models at Longer Horizons," is a study in routing the optimization signal through the pathway that is actually measured, and insulating the one that is not.

The problem is not the model, it is the pathway

A world model is a differentiable simulator. Given a state $s_t$ and an action $a_t$, it predicts $s_{t+1}$. Roll it forward $T$ steps, backpropagate, and you have a planner — in principle. In practice, the Jacobian of the full rollout with respect to an early action is a product of $T$ state Jacobians:

$$D_{a_0} \mathcal{F}^{T}(s_0, \mathbf{a}) \sim (D_s F_\theta)^{T-1} \cdot D_{a_0} F_\theta(s_0, a_0).$$

The conditioning scales exponentially with the horizon. Vanishing and exploding gradients are the well-known symptom. The less-discussed one is that the state Jacobian $D_s F_\theta$ is untrustworthy even when well-conditioned, because of adversarial robustness. You can have a perfectly conditioned product of liars.

Why long horizons are the real stress test

At short horizons the greedy solution is often good enough. As horizons grow, longer tasks are more likely to require non-greedy behavior — going around a wall, repositioning before pushing — and the optimization space itself scales with horizon: $\dim(\mathcal{A} \times \cdots \times \mathcal{A}) = T \cdot \dim(\mathcal{A})$, expanding the space of local minima. Longer horizons multiply the brittleness of every wrong routing decision you made earlier in the stack.

The dimpled manifold, or why the state gradient is adversarial

The training process controls a model's behavior tangential to the data manifold but does not regularize orthogonal directions. The result, as Stutz et al. (2019) laid out, is a "dimpled manifold": smooth along the data, sharp off it. A world model trained on state-action trajectories has a state-data manifold bounded by the action space plus a small augmentation space — far below the full state dimension. So most directions in state space are off-manifold, and off-manifold means the gradient is adversarial: a tiny perturbation can trick $F_\theta$ into reporting that an arbitrary state has reached an arbitrary goal.

This is not a vision curiosity — adversarial examples appear in LLMs and in RL. And as the GRASP authors note, citing Tsipras et al. (2019), there is a known trade-off between model performance and adversarial robustness: the model must be sharper in normal directions to fit complicated functions. Modern training does not, and under current regimes cannot, train this brittleness out. This is a problem we are stuck with.

[UNIQUE INSIGHT] The brittleness is structural, not a tuning failure. You cannot regularize it away without giving up the expressiveness that made the world model worth training. The only lever is which pathway you route the optimization signal through. That reframes the planner's job from "optimize harder" to "route correctly."

GRASP routes through the action gradient

Here is the move that makes GRASP work. The action space is low-dimensional and exhaustively trained — the model has seen essentially every action direction during rollout collection. So $D_a F_\theta$ is well-behaved. The state space is high-dimensional and sparsely covered, so $D_s F_\theta$ is not. GRASP builds a collocation (lifted-state) planner — optimize states and actions jointly, with dynamics as a soft penalty — and then stops the gradient from flowing into the state input of $F_\theta$. The signal reaches the model only through the action input. The state iterates still get updated, but by a dense goal-shaping term and stochastic noise, not by the adversarial state Jacobian.

Lifting buys parallelism across time

The collocation move treats the dynamics constraint $s_{t+1} = F_\theta(s_t, a_t)$ as a soft penalty and optimizes over both the action sequence and the state sequence jointly:

$$\min_{\mathbf{s}, \mathbf{a}} \sum_{t=0}^{T-1} |F_\theta(s_t, a_t) - s_{t+1}|^2, \quad s_0 \text{ fixed}, ; s_T = g.$$

Each world model evaluation now depends only on local variables, so all $T$ terms compute in parallel across time. You no longer backpropagate through a single deep $T$-step composition; the product of Jacobians that caused the exponential conditioning problem splits into a sum. The global minimizers are unchanged — both objectives are zero exactly when the trajectory is dynamically feasible — but the landscape is dramatically different.

The two ingredients that make the lifted planner tractable

Lifting alone does not work for deep world models, because now you are directly optimizing states through $F_\theta$ — exactly where the adversarial brittleness lives. GRASP adds two ingredients.

Ingredient 1 — exploration by noising the state iterates. Gaussian noise is injected into the virtual state updates during optimization:

$$s_t \leftarrow s_t - \eta_s \nabla_{s_t} \mathcal{L} + \sigma_{\text{state}} \xi, \qquad \xi \sim \mathcal{N}(0, I).$$

Actions still descend by non-stochastic gradient. The state noise lets the planner hop between basins in the lifted space while actions stay guided by clean gradients. This is not Langevin dynamics — only the states are stochastic — and the asymmetry is deliberate: noise the part you cannot trust, descend the part you can.

Ingredient 2 — stop-gradient dynamics loss plus dense goal shaping. Stop the state gradient into $F_\theta$:

$$\mathcal{L}{\text{dyn}}^{\text{sg}} = \sum{t=0}^{T-1} |F_\theta(\bar{s}t, a_t) - s{t+1}|^2.$$

Alone, this fails: states only chase the previous step, with nothing forcing the base states to chase the next ones, and trivial minima appear at the origin. So GRASP adds a dense goal term throughout the prediction:

$$\mathcal{L}{\text{goal}}^{\text{sg}} = \sum{t=0}^{T-1} |F_\theta(\bar{s}_t, a_t) - g|^2.$$

In a normal setting this would over-bias toward the greedy straight-line solution. Balanced against the stop-gradient dynamics loss — which biases toward feasible transitions — the two cancel into a planner that is both guided and grounded. The final objective has no dependence on state gradients.

Periodic sync keeps the lifted states honest

Every $K_{\text{sync}}$ iterations, GRASP briefly rolls out the current actions through the true serial objective and takes a few small gradient steps. The lifted optimization does the heavy lifting; the sync keeps states and actions grounded toward real trajectories. The refinement step is compositional — swap in any serial planner (CEM, for example). The architecture is a measured pathway with a periodic reality check.

The measured pathway is the one that is trained

[PERSONAL EXPERIENCE] I have spent enough time building forecasting systems to recognize the pattern: the component that fails is almost never the one you are monitoring. GRASP's authors did not discover a new optimizer. They identified which pathway carried a reliable measurement — the action gradient, densely sampled during rollout collection — and which carried an unreliable one — the state gradient, adversarial off-manifold — and they routed accordingly. The math is the math; the engineering insight is the routing.

This is the same discipline we apply at Everythink. Theorem 3, from the 21 papers, states a property is guaranteed exactly when its mechanism is implemented and measuring. "Implemented and measuring" is a routing decision. You find the pathway where the signal is grounded in data, and you refuse to ship a guarantee that depends on a pathway where it is not. A forecast that depends on an unmeasured pathway is not a forecast; it is an assertion with a probability sticker on it.

The space is the router. In our topology, a network contains communities, communities contain rooms, and the room is where a request lands before anything responds. Routing happens before retrieval, before generation, before any gradient is computed. GRASP makes the same architectural choice at a different scale: the action input is where the signal enters the model before any state propagation is computed. The routing decision — action in, state insulated — is what makes the long horizon tractable.

What long-horizon planning costs when you route wrong

The Push-T benchmark in the GRASP paper is unambiguous about the cost of routing through the wrong pathway. Success rate and median time to success, by horizon:

Horizon	CEM	GD	LatCo	GRASP
H=40	61.4% / 35.3s	51.0% / 18.0s	15.0% / 598.0s	59.0% / 8.5s
H=50	30.2% / 96.2s	37.6% / 76.3s	4.2% / 1114.7s	43.4% / 15.2s
H=60	7.2% / 83.1s	16.4% / 146.5s	2.0% / 231.5s	26.2% / 49.1s
H=70	7.8% / 156.1s	12.0% / 103.1s	0.0% / —	16.0% / 79.9s
H=80	2.8% / 132.2s	6.4% / 161.3s	0.0% / —	10.4% / 58.9s

Gradient descent through the full rollout — the pathway that uses both the action and the state Jacobian — collapses from 51% at horizon 40 to 6.4% at horizon 80. LatCo, another collocation method that does not stop the state gradient, is at 0% by horizon 70. GRASP, which routes only through the action Jacobian, is the only method that stays above 10% at horizon 80, and it does so in under a minute where GD takes nearly three. The collapse is not a horizon tax. It is the cost of routing the signal through a pathway that is not measured.

CEM, a sampling-based planner that does not use gradients at all, holds up better than GD at horizon 40 but collapses by horizon 60. The wrong gradient is worse than no gradient, because it carries false confidence.

How this connects to a calibrated forecast

Our Sisters are typed AI agents that each imagine a plausible future for a real-world actor; the Oracle merges their outputs into a calibrated probability cone. The architecture is a parallel fan-out — each Sister drafts independently, the Oracle normalizes — and the calibration is a measurement, not an assertion. The ensemble is normalized in exactly one place and the entropy is reported in nats. That is Theorem 3 in production: the normalization mechanism is implemented and measuring, so the property (sum of probabilities ≈ 1.0) is guaranteed.

GRASP's collocation move — lift the trajectory into virtual states so all timesteps optimize in parallel — is structurally the same as our Sisters fan-out. Parallelism across time and parallelism across agents both buy exploration without serializing through a single deep graph. In both cases, the merge step (the Oracle for us, the periodic sync for GRASP) keeps the parallel drafts honest. Parallelism without a merge step is just noise.

HAI Engine ✅ has been in production since 2016. Sisters ✅ and Oracle ✅ are production. World Monitor ✅ routes and caches real-world signals on a planetary scale — but it does not forecast conflict; it surfaces the signals, and a human decides what they mean. That boundary mirrors GRASP's: the action gradient it trusts, the state gradient it does not.

What GRASP does not claim, and why that matters

The authors are explicit about the limits. GRASP is "an initial iteration for such planners." Extension to diffusion-based world models, more sophisticated noising strategies, and integration into closed-loop RL are listed as next steps, not achievements. The Push-T results are a benchmark, not a deployment claim.

This is the honesty posture we hold ourselves to. Matchmaking ⚠️ and Marketplace ⚠️ are Partial — they work, and we will not oversell them. Calendar ⚠️ is Partial. Wallet & Token 🔵, Super App 🔵, and Community Credit 🔵 are Roadmap, pre-revenue, subject to Howey review. We do not quietly promote a Roadmap item to Production because a benchmark looked good. Customer sovereignty — your network, your brand, your data — is the topology the system routes through. And the ethics of scope is a routing decision too: civil and defensive use only, inclusion by design for multilingual, multimodal, low-connectivity contexts.

[ORIGINAL DATA] In our own forecasting work, the single largest source of miscalibration is not the model's parameter count — it is the gap between the pathway the team believes carries the signal and the pathway the measurement says actually does. Closing that gap is a routing exercise, not a training exercise. Every time we have improved calibration, the change was a routing change: where the signal enters, where it is normalized, where it is checked. Parameter counts moved only when the routing was already correct.

Key takeaways

• Route through the measured pathway. GRASP works because the action gradient is densely trained and the state gradient is adversarial off-manifold. The planner succeeds by stopping the signal from entering the brittle pathway.
• Lifting buys parallelism, routing buys correctness. Collocation parallelizes across time; stop-gradient routing keeps the signal clean. You need both, in that order.
• Theorem 3 generalizes the principle. A property is guaranteed exactly when its mechanism is implemented and measuring. The action gradient is the measured mechanism; the state gradient is the unmeasured one.
• Long horizons multiply brittleness, not just cost. The 80-step collapse of GD and LatCo is the adversarial Jacobian compounding. The wrong gradient is worse than no gradient.
• Honesty about limits is part of the mechanism. GRASP's authors label their work an initial iteration. We label our Roadmap items Roadmap. Both are a scope decision.

FAQ

Does GRASP mean world model planning is solved? No. The authors frame it as an initial iteration. Diffusion-based world models, closed-loop integration, and richer noising strategies are open. What GRASP demonstrates is that routing the gradient through the measured pathway is the lever that makes long-horizon planning tractable.

Why does stopping the state gradient not break the planner? Because the dense goal-shaping term and the stochastic state noise carry the signal the state Jacobian would have carried, without the adversarial brittleness. The periodic sync grounds the lifted states against the true rollout. The state gradient is replaced, not removed.

How is this different from LatCo? LatCo is also a collocation planner, but it does not stop the state-input gradient. Its 0% success at horizon 70 is the cost of routing through the adversarial pathway. GRASP's contribution is the routing decision, not the lifting.

What does this have to do with Everythink? The routing principle is the same. "The space is the router" means the network-community-room topology routes a request before any model responds. GRASP routes the gradient through the action input before any state propagation is computed. Theorem 3 is the formal version: guarantee the property only on the pathway where the mechanism is measuring.

Is the HAI Engine a world model? The HAI Engine is the production forecasting system that runs the Sisters and the Oracle. It is not a learned dynamics model in the GRASP sense. The connection is architectural: both systems route the signal through the measured pathway and refuse to ship guarantees that depend on the unmeasured one.

Sources

• 2026 — BAIR Blog, "Gradient-based Planning for World Models at Longer Horizons" — https://bair.berkeley.edu/blog/2026/04/20/grasp/
• Psenka, Rabbat, Krishnapriyan, LeCun, Bar (2026), "Parallel Stochastic Gradient-Based Planning for World Models" — https://arxiv.org/pdf/2602.00475
• Stutz, Hein, Geirhos, Schölkopf, Bethge (2019), "Disentangling Adversarial Robustness and Generalization" — https://arxiv.org/pdf/1812.00740

---

Ready to route your forecasting through the measured pathway? Create your network or read the 21 papers.