1.5 — Open-Loop vs. Closed-Loop Robot Execution

Learning objectives

After this lesson, you should be able to:

• Define open-loop and closed-loop execution.
• Explain why a disturbance defeats an open-loop plan.
• Describe action chunking with receding-horizon execution.
• Explain the trade-off between looking often and model speed.

The one-sentence idea

Open loop executes a plan without looking; closed loop looks and corrects as it goes.

How often the robot looks is a design choice with a cost.

Open loop and closed loop

Feedback means using a measurement of the output to adjust the input. It is the central subject of the control textbook by Åström and Murray, and a system without that measurement is called open loop.^[1] A robot that computes a whole plan from the first camera frame and then executes it without looking again runs open loop. A robot that re-observes and corrects as it moves runs closed loop. Lesson 1.1 showed why this matters: sensing and acting are uncertain,^[2] so a plan that ignores the result accumulates error.

The experiment below makes the difference concrete. The task is the same as in lesson 1.1: move a hand from 0 to 1. This time there is also a steady disturbance that pushes the hand a little on every step, such as friction or a slight miscalibration. The open-loop controller replays a precomputed plan. The closed-loop controller measures the position each step and corrects the remaining distance.

import numpy as np
rng = np.random.default_rng(0)

def run(closed_loop, steps=20, noise=0.01, push=-0.004, trials=1000, tol=0.05):
    ok = 0
    for _ in range(trials):
        pos = 0.0
        for _ in range(steps):
            if closed_loop:
                move = 0.5 * (1.0 - pos)                 # look at where the hand is, move halfway to the goal
            else:
                move = 1.0 / steps                       # replay the plan: equal steps, no looking
            pos += move + push + rng.normal(0, noise)    # the world: the command, a steady push, and random error
        ok += abs(pos - 1.0) < tol
    return ok / trials

print("open loop  success rate:", run(False))
print("closed loop success rate:", run(True))

open loop  success rate: 0.268
closed loop success rate: 1.0

Toy model. The disturbance, noise and controller are made up. They illustrate why feedback helps, not the performance of any robot.

The open-loop plan is wrong by about the sum of the pushes (20 × 0.004 = 0.08), and it never notices. The closed-loop controller keeps correcting, so the push only shifts where it settles by a small amount.

In between: act on a chunk, then look again

Between the two extremes is a middle path used by recent policies: predict several future actions at once (a chunk), execute part of it, then query the policy again. Diffusion Policy predicts a sequence of future actions and uses receding-horizon control, in which part of the sequence is executed and then the policy is queried again.^[3] ACT also predicts action chunks, and the paper uses action chunking and temporal ensembling to reduce compounding errors.^[4]

Chunking is a trade-off. A long chunk means fewer model calls, which helps when the model is slow, but the robot is open loop for the length of the chunk. The next example repeats the experiment above but re-observes only every k steps, where the plan for the next k steps is computed from the last observation:

import numpy as np
rng = np.random.default_rng(0)

def run(k, steps=20, noise=0.01, push=-0.004, trials=1000, tol=0.05):
    ok = 0
    for _ in range(trials):
        pos = 0.0
        for t in range(steps):
            if t % k == 0:                                     # look, and plan the next k moves
                remaining = steps - t
                per_step = (1.0 - pos) / remaining             # spread the remaining distance over the remaining steps
            pos += per_step + push + rng.normal(0, noise)
        ok += abs(pos - 1.0) < tol
    return ok / trials

for k in (20, 10, 5, 2, 1):
    print("look every", k, "steps -> success rate", run(k))

look every 20 steps -> success rate 0.268
look every 10 steps -> success rate 0.618
look every 5 steps -> success rate 0.897
look every 2 steps -> success rate 0.999
look every 1 steps -> success rate 1.0

Toy model. This is our own illustration of the trade-off, not ACT or Diffusion Policy.

Looking more often helps in this setting: success rises from 0.27 at 20 steps per look to 0.62, 0.90 and 0.999 at 10, 5 and 2. Looking more often costs a model call each time. How much it costs depends on the model, which is why the speed discussion in lessons 1.1 and 1.4 and the choice of chunk length belong together.

Closing the loop at the planning level too

Feedback is not only about motor commands. Inner Monologue adds closed-loop language feedback to planning with language models, from sources such as success detectors, object detectors and humans, which significantly improves instruction completion and lets the planner replan around failures.^[5] The pattern is the same: act, observe, and use the observation to decide what to do next.

Why speed and loop are linked

A closed loop is only as responsive as its slowest stage. If a model runs at 3 Hz, as RT-1 did,^[6] the loop can correct at most three times a second, and the world moves between corrections (lesson 1.1). Running open loop for a chunk is one way to use a slow model without stopping the robot, and re-observing often is the way to stay accurate. The choice between them, and between model sizes, depends on the task and the hardware; the experiment above is only a toy of that trade-off.

Common misconceptions

Engineering takeaways

1. Open loop has no measurement of the result; closed loop does.
2. Small steady disturbances break open-loop plans.
3. Chunking trades responsiveness for fewer model calls.
4. Feedback applies to planning as well as to motion.

A robot that cannot look at the result is only guessing that the plan worked.

Knowledge check

Try each question first, then reveal the explanation.

What’s next

That completes the introduction. Next come the core concepts: observations, actions and policies.

Back to the VLA roadmap