A full Rocket Bench run, controlled by the generated network.

The model was gone before launch. The flight was controlled by the deterministic network it had generated.

The bench#

Rocket Bench is a toy simulator with two gravitational bodies and one rocket. The target was a planet-bound orbit reached through launch, altitude gain, ballistic coast, and circularization.

On screen, the task looks almost trivial. The controlled object, however, is itself a moving body inside the combined gravitational field of two others. Its position, velocity, and orientation evolve together, and every correction changes the conditions under which the next one will act.

The controller sees 14 continuous state variables and can set four command variables at each step. A flight spans about 100 control steps. The model could not inspect the simulator code. It received basic parameters such as gravity, thrust, and target orbit radius, together with the telemetry and command schemas.

The failed loop#

First, language models were asked to read the telemetry and issue the next command. They were also asked to generate conventional control algorithms. None of the tested runs completed orbital insertion. Small errors accumulated across a continuous state space, and a plausible local correction did not amount to a flight plan.

Change the object#

The useful change was to stop asking the model for the next action. Instead, it generated a closed-world environment model as a small algebraic network. Simulator state was reflected as logical facts. The target orbit became a constraint inside the same model. Launch, ascent, coast, and circularization became explicit phases with explicit transitions.

In a broad sense, this was still code generation. The difference was not executability, but where the semantics came from. The model did not invent an arbitrary control loop. It assembled a controller within a fixed algebra of facts, guards, and transitions, with the goal represented inside the same system.

Ordinary generated code can hide state and assumptions inside control flow. Here the current state, admissible moves, and goal test remained explicit. The fixed runtime decided what could fire and carried the state forward deterministically.

At runtime, the language model was gone. A token moved through the generated network. Current facts enabled transitions, and those transitions produced commands for the simulator.

What it shows#

The generated network launched the rocket and reached the simulator's planet-orbit condition. The trajectory is not a clean demonstration of general orbital control. It is one generated controller in one deliberately small world.

The more useful result is the division of labour. The generative model built a bounded executable world, then left. A deterministic process carried the state, checked the goal, and acted inside it.