A First Glance At Weight-Space Programming for Robotics

Playground researchNovember 2026Research note

We asked frontier LLM agents (Claude Opus 5.5 and GPT-6 Astra) to edit robot policies and build new ones by writing their weights directly, with no gradient descent, no new demonstrations and no simulator in the loop while they work. On small policies, the agents removed learned failure habits and taught a new skill by rewriting a handful of neurons. On π0.5, an edit that touches 2,048 weights raised success on a perturbed LIBERO task. We also found that Astra could construct neural networks from scratch for cart-pole swing-up, cube pushing and peg-in-hole insertion. This is a first glance, with small samples and a limited set of simulated tasks.

Figure 1. Held-out scene 4, run by the original π0.5 (left) and by π0.5 with two agent-written edits, Lower Carry and Brake Flip (right). The resized mug is wider and squatter than the mug in the LIBERO demonstrations π0.5 was fine-tuned on. The original policy carries it too high, so the tilted mug catches on the edge of the microwave opening and wedges there, and the arm keeps pushing until time runs out at step 520. The edited policy carries it lower, lets go, and closes the door at step 283. Both clips replay the scored episodes exactly. We cut steps 320 to 440 of the failure, where nothing changes.

What if an LLM could edit a robot policy the way an engineer edits code?

We used two frontier models, Claude Opus 5.5 at maximum reasoning effort and GPT-6 Astra at xhigh reasoning effort, and each one worked alone in a Python sandbox that had numpy but no internet access and no simulator. Every change to the weights had to come from the agent's own reasoning about what the network computes, because gradient descent, fitting the weights to data and any kind of search were not allowed.

Two ways to change a robot policy
TRAINING, THE USUAL WAY New demonstrations hours of teleoperation Gradient descent every weight moves a little New policy opaque change, new failures possible WEIGHT-SPACE PROGRAMMING Weights + a few recorded failures no new data An LLM reads and reasons traces which neurons drive the failure, tests ideas on saved inputs A targeted edit a few neurons, each with a stated purpose, then scored in simulation by us
playground / Weight-space programming
Figure 2. In training, every weight moves a little and the reason for any one change is unknowable. In weight-space programming, an LLM proposes a small, explained edit, and the edit is then scored on scenes the LLM never saw.

We start small, with MLP policies that drive a simulated Franka Panda arm to pick up a 44 mm cube and place it at a target. We plant a weakness or ask for a new behavior, then give the agent the weights, one to five recorded runs and a task description. It cannot run the simulator (only a model of the arm it writes itself) or see the scored starts, and it may edit only the weights into the second hidden layer, which rules out re-mapping inputs or outputs.

A warm-up on small policies

We trained a policy with 1,024 neurons per layer on demonstrations that drop the cube mid-carry whenever it starts on one side of the table. It learned the habit and passed 25 of 50 starts. The agent turned two never-used neurons into a "keep holding" signal and a small path correction, 0.19% of the weights, and the edited policy passed all 50. On a network 16 times larger, two rewritten neurons again fixed every failure, beating the same network fine-tuned on 10 demonstrations.

Figure 3. The cube task, run by the scripted expert that generates the training demonstrations. A start passes if the cube ends upright and still within 20 mm of the target, with the gripper open and nothing else disturbed.

Removing a learned habit

Agents can also add behavior a network never learned. From one recorded run, an agent rewired 28 neurons that are silent during the pick, so a policy trained only to place the cube now stacks it on another block, although it can no longer do the original placing task. Another moved the drop-off point 100 mm with the input and output layers locked, using five unused neurons.

Cube height during three runs that failed before the editsame starting positions
0 50 100 0 s 2 s 4 s 6 s 8 s 10 s 12 s Cube height (mm) dropped mid-carry set down at the target Original policy (drops the cube) After the 2-unit edit
playground / Weight-space programming
Figure 4. Simulator traces of cube height in three starts where the original policy drops the cube (orange). After the two-neuron edit, the same starts reach the target (blue). Over 50 unseen starts the edit fixed all 25 failures and broke none (exact McNemar p = 6 × 10⁻⁸). A second agent, working alone, rewrote two neurons, one of them the same, and passed 19 of 20 starts against 9.

Teaching new behavior

The agents could also add behavior that a network never learned. Given one recorded run, an agent rewired 28 neurons that are silent during the pick, so a policy trained only to place the cube now stacks it on another block, with the pick unchanged bit for bit. The cost is that the edited policy no longer does the original placing task. Another agent moved the drop-off point 100 mm with the input and output layers locked, by turning five unused neurons into sideways pushes.

Success before and after, small policies
0% 25% 50% 75% 100% Unlearn a drop habit 1.06M weights, 2 units rewritten 50% no fine-tune scored 100% Same habit, 16× larger network 16.8M weights, 2 units rewritten 60% 88% 100% Teach a new skill, stacking 200 units, 28 rewritten 0% 46% 100% Move the drop-off point 200 units, 5 rewired 0% 94% 98% Before the edit Fine-tune on 10 demos After the LLM's edit
playground / Weight-space programming
Figure 5. Success on unseen starts for the four small-policy tasks. "Before" is the policy the agent received, and "Fine-tune" is the same network trained further on 10 demonstrations, to convergence for the larger network and for stacking. Against the fine-tune, the edit was ahead on the larger network (50 against 44 of 50, p = 0.031) and on stacking (50 against 23 of 50, p = 1.5 × 10⁻⁸), and level on the drop-off point (49 against 47 of 50). Each agent run took 17 to 74 minutes and cost $3 to $18.

Editing π0.5, a 3.35-billion-parameter robot foundation model

We used the public pi05_libero checkpoint of π0.5, which scores in the high 90s on most LIBERO tasks. A 3-billion-parameter vision-language model reads the two camera images and the instruction, and a 300-million-parameter action expert turns that into a 10-step action chunk over 10 flow-matching denoising steps. The robot executes the first 5 steps of each chunk, then replans.

Where the agents could edit π0.5
Base camera224 × 224 Wrist camera224 × 224 Instruction"put the mug in…" Vision-language model SigLIP + Gemma, ~3B frozen Action expert, 18 layers, ~300M 01234567891011121314151617 blue layers 1 to 16 are editable, grey ones are locked 10-step action chunk 5 executed
playground / Weight-space programming
Figure 6. The agents could edit the MLP weights of the action expert's middle layers 1 to 16. Everything else, including the vision-language model, the first and last layers and all normalization statistics, stays exactly as released.

The agent gets

  • The action expert's MLP weights
  • Human demonstrations of the original task (images, states, actions)
  • 60 recorded rollouts of π0.5 on freshly sampled scenes, each labelled with how it failed
  • A probe that runs its edit through the full 3.35B-parameter model on 32 to 48 fixed camera frames and returns the actions and every layer's activations, with no limit on calls
  • Python with numpy

Not allowed

  • A simulator, so it never sees its edit move a robot
  • The 50 scored scenes, or any rollout from them
  • The vision-language model's weights, the first and last layers, normalization statistics
  • Gradient descent, fitting or automated search over weights
  • The internet
Experiment 1

Can an LLM improve π0.5 on a task it already does fairly well?

Policy
π0.5 (pi05_libero) on LIBERO-10 task 8, "put both moka pots on the stove"
Agent gets
the action expert's MLP weights, 26 human demonstrations, 60 labelled rollouts on fresh scenes, a probe on 32 frames, Python with numpy
Not allowed
the simulator, the 50 scored scenes, the vision-language model, layers 0 and 17, fitting or automated search
Scoring
50 held-out scenes, 3 runs of the edit against 6 runs of the original, then one exact pass of each under repeatable scoring

On LIBERO-10's hardest task, "put both moka pots on the stove", π0.5 succeeds about 58% of the time. The failures have a clear signature. After placing the first pot, the gripper comes down about 2 cm short over the second pot's handle, a finger lands on top of the handle, and the policy hovers there, pressing weakly, until time runs out.

Figure 7. One of the 60 development rollouts the agent received, showing the original π0.5 on LIBERO-10 task 8 with the wrist camera on the right. The first pot reaches the stove, and the gripper then hovers over the second pot's handle and never closes on it, until time runs out at step 520. We cut steps 360 to 480, where nothing changes.

One agent, which we call Handle Nudge, turned four nearly dead neurons in layer 16 into a single gated unit. Its gate fires only during the approach to the second pot, using a signal the network already computes ("the first pot is already placed"), and its output pushes the grasp about 1.4 cm toward the handle.

Figure 8. Held-out scene 39, run by the original π0.5 (left) and by π0.5 with Handle Nudge (right), replayed exactly from one repeatable pass. The original places the first pot, then hovers over the second pot's handle without closing on it until time runs out at step 520. The edited policy closes on the handle and finishes at step 412. In the same pass the edit fixed 9 held-out scenes, this one among them, and broke 10. We cut steps 415 to 515 of the original's hover.

Averaged over 3 runs of the edit and 6 runs of the original, success rose from 28.8 → 31.7 of 50 (standard error of the gain 1.2, one-sided permutation p = 0.024). Those runs came before we made scoring repeatable, however, and one exact repeatable pass gave 29 of 50 for the edit against 30 for the original, with 9 scenes fixed and 10 broken. We therefore count this gain as unconfirmed.

Experiment 2

What happens on a harder task?

Policy
π0.5 (pi05_libero), LIBERO-10's microwave task with the mug resized (LIBERO-Pro2.0, perturbation S08)
Agent gets
the action expert's MLP weights, 34 demonstrations with the normal mug, 60 labelled rollouts on fresh scenes, a probe on 48 frames, Python with numpy
Not allowed
the simulator, the 50 scored scenes, the vision-language model, layers 0 and 17, fitting or automated search
Scoring
the 50 standard held-out scenes, one exact run each under repeatable scoring, compared scene by scene

To find room for larger gains, we screened the LIBERO-Pro2.0 perturbations that change an object's shape or size. π0.5 handled most of them well (70 to 90% success). The hardest one whose failures were the robot's own mistakes was LIBERO-10's microwave task with the mug resized to 1.28 times the width and depth and 0.72 times the height. π0.5 solves 34 of the 50 standard held-out scenes.

Fails, with the mug reaching the opening too high
Four frames from a failed rollout, in which the arm carries the squat yellow-and-white mug to the microwave, where the mug catches on the opening and tips
Succeeds, with a lower entry in another scene
Four frames from a successful rollout, in which the arm carries the mug low into the microwave and releases it
Figure 9. Two rollouts of the original π0.5 on the resized mug, from the development scenes the agents received. In both, the policy grasps and lifts the mug without trouble. In the failure, the mug reaches the microwave too high, catches on the opening and wedges at an angle.

The rollout data points to two problems. π0.5 carries the squat mug about 2 cm higher than the demonstrators carried the normal mug, so its rim catches the top edge of the opening. The higher the mug when it reaches the microwave, the more often the episode fails. And once the mug is stuck, the arm keeps pushing and never lets go. Each action chunk plans the release for steps 6 to 9, but the robot replans after step 4, so a blocked arm replans the same push until time runs out.

Success by the mug's height at the microwave opening60 rollouts of the original π0.5
0% 25% 50% 75% 100% 10 of 11 succeed below 97.5 cm 21 of 34 succeed 97.5 to 99.5 cm 5 of 15 succeed above 99.5 cm Mug height in simulator coordinates as it crosses into the microwave
playground / Weight-space programming
Figure 10. The 60 development rollouts we gave the agents, grouped by how high the mug was as it crossed into the microwave. Low entries almost always succeed, and high ones mostly fail. This is the kind of evidence the agents built their edits on.

Two edits address these problems, and a different agent, working alone, wrote each one. Lower Carry rewires one neuron in layer 16 that fires only while the gripper holds the mug, so that it now also pushes the arm down, and the mug travels about 2 cm lower. Brake Flip targets a neuron in layer 10 that fires when a release is planned but pushes against letting go, a brake that keeps a stuck arm pushing. The edit rewires its 1,024 output weights so the same neuron now pushes toward letting go.

Together, the two edits take π0.5 from 34 → 44 of 50 held-out scenes (68% → 88%) while changing 2,048 of its 3.35 billion weights, about 0.00006% of the model. Brake Flip alone reaches 43 of 50.

Held-out successes, one exact run eachdashed line marks the original π0.5
0 10 20 30 40 50 Original π0.5 34 / 50 Lower Carry (2 neurons) 36 / 50 Lower Carry (1 neuron) 39 / 50 Lower Carry (2 neurons) + Brake Flip 41 / 50 Brake Flip 43 / 50 Lower Carry (1 neuron) + Brake Flip 44 / 50
playground / Weight-space programming
Figure 11. Successes on the 50 held-out scenes, which no agent ever saw. "Lower Carry (2 neurons)" is an independent version of the same idea built from two layer-6 neurons. Scores come from our repeatable scoring setup, so each bar is exact for these 50 scenes.
PolicyWhat changesWeights changedHeld-outFixedBrokenMcNemar p
Original π0.5nothing034/50n/an/an/a
Lower Carry + Brake Flipone layer-16 neuron's output, plus one layer-10 neuron's output2,04844/501660.053
Brake Fliplayer-10 neuron 2491 now pushes toward releasefound by tracing the failing action backward1,02443/501340.049
Lower Carry (2 neurons) + Brake Fliptwo layer-6 neurons built into a carry detector, plus Brake Flip7,16841/501140.12
Lower Carrylayer-16 neuron 3769 lowers the carry about 2 cm1,02439/50830.23
Lower Carry (2 neurons)two layer-6 neurons, the same idea built earlier in the network6,14436/50750.77
Figure 12. A second held-out scene (37). The original π0.5 gets the mug stuck at the opening, pushes it slowly inside and never lets go, so the door is never closed. With the two edits, the policy releases the mug and closes the door at step 324. Same scene and same random seed, and only 2,048 weights differ. We cut steps 340 to 460 of the failure.

How do the agents find these fixes?

We found that the successful agents follow the same steps. They start from the robot's behavior, find a physical quantity that predicts failure, look inside the network for the neurons that carry the relevant phase of the task, rewire one of them, and check on saved camera frames that only the intended frames change.

Started from the idea "correct position errors more strongly", then changed course when the data pointed somewhere else.

  1. Observerollout data
    "Grasp and lift always succeed, so the failures are in the microwave step. I'm checking rollout images to see what happens physically."
  2. Measurephysics
    "Timed-out episodes enter the microwave about 2 cm higher than successes and demos."

    It then measured how strongly the policy corrects height on the way in, about 40% of the error, and found the policy aims for the wrong height rather than correcting too weakly. So it dropped its starting idea.

  3. Decidetarget
    "Top-edge catches all came with mug z ≥ 0.989 at y=0.12 ... so lowering the carry about 1.5 cm should clear most failures."
  4. Look insideactivations
    "Unit 3769 in layer 16 is a near-perfect carry-phase gate, firing strongest on the frames where the correction matters."

    The neuron is exactly zero before the grasp and after the release, and strongly active whenever the mug is held.

  5. Rewireone neuron
    "I'm adding a −dz component to its layer-16 output row to run the first causal test and measure the effect."
  6. Testprobe frames
    "The first causal test is a clean control. Pre-grasp and post-release frames barely move, while carry frames drop in dz by 0.015 to 0.035."

    It tried layers 14 and 15 as well, found the effect weaker or less consistent, blended two directions to cancel a sideways drift, and set the strength to a 2 cm drop.

  7. Hand offto us
    "Expected about 34 → 39 successes out of 50, plausibly anywhere from +0 to +8."

    Measured alone, it scored 39 of 50. Its prediction was right on.

Figure 13. Condensed reasoning traces of the two agents behind the best edit, quoted from their transcripts. Neither agent ever saw a robot move under its edit.
The edit the agents keep reaching for, a rewired neuron
residual stream (the information flowing through the layers) neuron 3769 reads "the mug is held" input weights (kept) writes "move down" output weights (edited, 1,024 values)
playground / Weight-space programming
Figure 14. Almost every successful edit in this post has this shape. The agent finds a neuron whose input side already detects a phase of the task (holding the mug, a release being planned), or builds one from a nearly unused neuron, and edits its output side to write a specific correction. Everything outside that phase is left alone, because the neuron is silent there.

Building a neural network from scratch

Can an LLM write a neural network that controls a robot, without training it or testing its behavior? Following the original weight-space programming experiments, we asked Astra to build these policies from scratch for three tasks in simulation.

Astra chose how many layers and neurons each network would have, then used Python to calculate the weights. We froze those numbers before running the network in MuJoCo, a physics simulator. During a run, the network controls the robot; the LLM does not choose its actions. The weights stay fixed while the network reads observations and produces motor commands 50 times a second.

Astra gets

  • The task rules and exact physical models
  • The network’s input and output layout
  • Python with NumPy to calculate and save weights

Not allowed

  • Pretrained weights, demonstrations, training or fitting weights to data
  • Internet access, a simulator, trajectory emulation or automated search
  • Private test cases or a separate controller running alongside the network
Agent
GPT-6 Astra (gpt-6-astra), xhigh reasoning, with a fresh session for each task.
Allowed checks
Static calculations and network checks on independent, made-up inputs; no simulated trajectories before submission.
Scoring
100 randomized test cases per task, kept hidden from Astra, plus 100 harder peg-insertion cases. A pass requires reaching the goal and holding it for one continuous second.

The first networks passed 100 of 100 cart-pole tests, 69 of 100 pushes, and 99 of 100 peg insertions. Astra wrote these weights before receiving any feedback on how they behaved.

TaskSuccesses / 10095% interval
Cart-pole: swing up and balance10096.3 to 100.0%
Cube pushing: move into the target6959.4 to 77.2%
Peg insertion: original ranges9994.6 to 99.8%
Peg insertion: harder ranges9487.5 to 97.2%

These tests use the first submitted weights. The two insertion rows use the same network on independent case sets; both sets of parameter ranges were disclosed to Astra. Intervals are Wilson 95% intervals across the 100 cases in each row.

Cart-pole · first recorded episode
Cube pushing · first episode, failed
Cube pushing · first successful episode
Peg insertion · first recorded episode
Figure 15. Replays of development runs from the first networks. We show the first cart-pole and peg runs, and the first failed and successful pushes. These are separate from the scored cases in the table.

How does it turn a control rule into weights?

Astra first worked out what each controller should calculate, then wrote Python to express those calculations as network layers. Each layer takes weighted sums of its inputs. Simple nonlinear operations between layers let the network combine different rules, cap a motor command, or approximate a curved function. The saved weights encode the controller Astra designed; they were not learned from experience.

Cart-pole: swing the pole up, then balance it.

Only the cart has a motor; the pole swings freely. The network reads the cart’s position and velocity and the pole’s angle and angular velocity, then chooses a horizontal force. Astra’s rule rocks the cart to build momentum, then balances the pole and brings the cart back toward the center.

Move the cart to lift and catch the pole5 inputs → 1 force
1. Build momentum 2. Balance + center Push with the swing Hold near upright for 1 second Cart + pole state Position, velocity, angle, angular speed Fixed neural network · 27 layers 145,418 weights and biases Cart force: −10 to +10 N
playground / Weight-space programming
Figure 16. Astra encoded two rules in one network: build the pole’s momentum, then balance it. Only the cart has a motor.

Cube pushing: get the whole block inside the target.

The Franka arm receives state values for its joints, the cube and the target, and outputs seven joint torques—the turning forces at its joints. Astra made the network act like a spring pulling the hand toward a point just behind the target center, with sideways corrections to keep the cube on course.

Push toward a fixed point behind the target center29 inputs → 7 joint torques
TOP VIEW 13 cm target square Hand 5 cm cube Hand reference 3.8 cm behind center Target center Joint, cube and target state 29 values from the simulator Fixed neural network · 10 layers 299,203 weights and biases · first version Seven joint torques
playground / Weight-space programming
Figure 17. The spring is a calculation inside the network. Its output drives the hand toward the marked point; the whole cube must fit inside the target for a pass. Cube and target positions vary, as does the cube’s starting rotation.

Peg insertion: find the hidden hole by touch.

The arm starts with a square peg already held above the nominal hole location. The actual hole position varies. The network receives recent joint states and wrist force and torque readings, but no camera image or actual hole position.

Astra designed a small spiral search, using the twisting forces sensed at the wrist to steer. As the network estimates that the peg is entering the hole, it reduces the sideways search and continues lowering the peg.

Hidden parameterOriginal rangesHarder ranges
Hole offset, each axis±4 mm±8 mm
Clearance per side1.5–2.5 mm0.75–1.25 mm
Sliding friction0.2–0.60.7–1.0

Each parameter is sampled independently. The peg and hole have matching orientation, and the arm starts in the same posture. Success requires at least 25 mm of insertion and a one-second hold inside the opening; the full fit, motion and force limits are below.

The same weights passed 94 of 100 cases with smaller openings, higher friction and larger hole offsets. All seven failures across the two test sets exceeded the 30 N contact-force limit.

Finding the opening, entering, and holding stillfirst recorded episode · no smoothing
0 2 Tip x from nominal hole (mm) −2 0 2 4 6 Tip y from nominal hole (mm) Search and entry Upright center-fit region Start Finish 0 2 4 6 Time (s) −20 −10 0 10 20 30 40 Depth below plate (mm) Scored depth range At least 25 mm deep for 1 second 0 2 4 6 Time (s) 0 5 10 15 20 25 30 Sum of contact-force norms (N) Peak force: 20.68 N Failure threshold: 30 N
playground / Weight-space programming
Figure 18. A recorded insertion with the first network. The green box shows where an upright peg’s center would fit; the network never received this hole position. Purple marks the final one-second hold. The force limit was checked every 2 ms; the plot samples every 20 ms plus the final state.

Can feedback improve the weights?

For pushing, we also tested one revision. Before scoring either version on hidden cases, a fresh Astra session received the original construction code and ten development recordings. The first network passed eight of those runs; in both failures, the cube drifted sideways. Astra could inspect the recordings and do static calculations, but could not train or simulate another run.

Astra strengthened the sideways steering and used the cube’s sideways velocity to compensate for drift. The revised network passed ten new development runs. On the same 100 hidden cases, success rose from 69 to 76: the revision fixed 22 failures but broke 15 successes. We made no further revisions after seeing these final scores.

Network sizes, control laws and exact scoring rules

What runs at evaluation. Each policy is an ordinary feed-forward network of affine layers (weighted sums plus biases) and ReLU operations; cart-pole also uses tanh at its output. The evaluator applies the disclosed input encoding and actuator scaling. The construction code does not run beside the policy.

NetworkInputs → outputsAffine layersWeights + biases
Cart-pole5 → 127145,418
Pushing, first29 → 710299,203
Pushing, revised29 → 710297,930
Peg insertion100 → 76219,818,049

Expressing calculations as layers. A ReLU returns its input when positive and zero otherwise. Combining affine layers and ReLUs implements clipping and absolute values exactly and approximates curved functions with straight-line segments. Multiplication can be expressed as ab = ((a+b)² − (a−b)²) / 4, with the squares approximated this way. For the arm, Astra also received static information about hand motion and gravity support at the starting posture.

All tasks use 2 ms physics steps and 20 ms control intervals. Success is checked at every physics step. The time limit is 15 seconds for cart-pole and pushing, and 30 seconds for insertion. Each task requires a continuous one-second hold.

Cart-pole setup and scoring. A 1 kg cart carries a freely hinged 0.1 kg, 1 m pole. Only the cart is actuated, up to ±10 N. The pole starts near hanging down. Success requires at most 10 degrees from upright and 0.5 rad/s angular speed, with the cart within 25 cm of center at no more than 0.25 m/s, continuously for one second. Crossing ±2.4 m fails immediately.

Cart-pole. With cart position x, velocity v, pole angle q measured from downward and angular speed w, the energy term is E = w²/60 + 0.4905(1 − cos q). The upright value is 0.981 J, and Astra chose a 1.12 J pumping target to allow for losses. Its local acceleration law is approximately a = 2.08245x + 4.12319v − 38.87627δ − 9.74879w, with δ the upright angle error. The force map is F = (1.1 − 0.075c²)a + 0.05v − 0.73575cs − 0.015cw − 0.05sw², where s = sin q and c = cos q. Rail-related acceleration limits and a bounded final tanh output are inside the network. Initial x and q are independently uniform in ±0.1 m and ±0.1 rad, and both velocities are independently uniform in ±0.05 in their respective units.

Pushing setup and scoring. The 5 cm, 80 g cube starts 5.5–8.5 cm ahead of the home hand position; the 13 cm-wide square target’s center is 14–18 cm ahead. Cube and target independently vary by ±1.5 cm sideways. The arm starts in the same posture. The entire rotated cube footprint must remain inside the target while touching the table for one second.

Franka. Forward stiffness is 220 N/m, capped at ±4 N. Vertical stiffness is 800 N/m, and pitch stiffness is 35 Nm/rad. Gravity and hand-position formulas use the planar joint model with a first-order gravity correction for departures from that plane. In the revision, sideways reference is clip(cy + clip(0.5(cy − gy), ±0.015) + clip(0.43910vy, ±0.020), ±0.080), in meters relative to the home hand position. Here cy and gy are cube and target positions, and vy is cube velocity. Seven outputs are scaled by torque limits [87, 87, 87, 87, 12, 12, 12] Nm. Fingers are fixed. Cube yaw is uniform over a full turn, and all stated position samples are independent.

Peg insertion. The peg is 20 mm square, 60 mm long and 50 g, fixed to the gripper above an unchamfered 40 mm-deep hole. Each of five frames contains q − home, q̇/3, wrist force divided by 20 N, and wrist torque divided by 2 Nm: 20 values per frame, newest first, spanning 80 ms. The sensor includes payload gravity and inertia. The network analytically approximates geometry, gravity and Jacobians around home, then maps a designed wrench to joint torque internally. Success requires 25–40.5 mm tip depth, the full horizontal peg projection fitting the opening, tilt ≤3°, tip speed ≤0.020 m/s, angular speed ≤0.10 rad/s, and penetration ≤1 mm for a full second. Penetration above 2 mm also fails. The force guard sums contact-force norms across the robot and fixture/support, so opposing forces cannot cancel. The wrist sensor measures only the peg payload. The vertical equilibrium is 32 mm deep. A combination of joint angles acts as the search-progress signal, so the network uses the arm’s motion rather than an external clock. Search fades as estimated entry begins; no captured hole center or external recurrent state is provided.

Development and final scoring. Cart-pole and peg insertion each passed all ten initial development runs and were not revised. Pushing used ten runs before its single revision and ten new runs afterward, within the available budget of 100 development runs per task. Development ended before any hidden-case outcomes were revealed. Both pushing versions were then scored on the same 100 cases: 54 passed with both, nine failed with both, 22 were fixed and 15 were broken by the revision. The revised network’s 76/100 success interval is 66.8–83.3% (Wilson 95%). The two development batches used different starts and are not a paired comparison.

These results show that Astra can construct working controllers and express them as neural weights for these simulated tasks. It was given the physical models and parameter ranges. Pushing uses a small workspace and a generous target; insertion begins with an already grasped, correctly oriented peg. We have not tested new robot geometry, noisy sensors, camera input or real hardware, and one authoring run per task does not establish reliable construction for arbitrary tasks.

Code, weights and sandbox audit

Was the author offline? Its tools had no internet access. Every Python call ran under an OS sandbox denying networking and reads of private evaluator files or unrelated policies. The trusted host still contacted the remote model service for inference. This was not an air-gapped machine, and it did not remove internet-derived pretraining knowledge.

Evidence files include per-case results and artifact hashes, original construction source, cart-pole construction, pushing revision, and isolation audit.

Peg-in-hole evidence includes all final outcomes, numeric weights, exact prompt, submitted control-law explanation and plotted trace.

Takeaways on how LLMs approach a policy's weights

From this first look, LLM agents do not treat weights as a black box to be searched.

Request an evaluation

Want to see how your robot policy holds up? Tell us about it, and we’ll be in touch shortly.