Skip to content
LumenaryAcademy
Frontier 85 min

Evaluation, safety and deployment of learned robots

How generalist robots are measured and how sure a measurement can be; how a learned policy is wrapped in safety filters and runtime monitors; the standards and laws that apply in late 2026; and the people who supervise robots, work beside them, and whose work they change.

Code tested · 6AI-draftedAwaiting review by a roboticist

Your guides: Gideon · The Safety Engineer, Chloe · The Builder, Margaret · The Experimenter

MotivationH

From the video to the shift

A robot that folds a towel in a video has shown that a robot can fold a towel. A robot that folds towels in a hotel laundry must do it hundreds of times a shift, with whatever towels arrive, beside people who never agreed to take part in an experiment, and stop safely when something goes wrong. The distance between those two robots is the subject of this last lesson of Lumenary Robotics.

The frontier lessons on VLAs, humanoids, world models and dexterous hands all ended on the same caveats: success rates from a few dozen trials, policies that do not know when they are failing, and safety standards written for machines that do exactly what they are programmed to do. Here we take them in turn: evaluation, and how much a measurement can tell you; safety, a filter and a monitor wrapped around a policy that offers no guarantees; and deployment, the laws of late 2026 and the people who work beside robots. Robots and people asked these questions for young readers; this is the professional version.

ExplanationH

How generalist robots are evaluated

A benchmark compares methods on shared tasks. An evaluation for deployment decides whether one system is good enough for one job, in one place, with particular people around it. Most published work is the first; what matters to a customer, a regulator or a bystander is the second.

Simulated benchmarks

Simulation offers thousands of cheap, exactly repeatable trials. The suites most used for generalist manipulation policies:

Benchmark (origin, year)What it measuresStatus, late 2026
CALVIN (University of Freiburg, 2021)chains of five language instructions on a simulated deskthe standard long-horizon test
LIBERO (UT Austin, 2023)130 language-specified tasks varying objects, layouts and goalssaturated: top VLAs exceed 95%, much of it memorisation
SIMPLER (2024)simulated copies of real Google and WidowX set-upsbuilt so that its rankings track real-robot results
RoboCasa (UT Austin and NVIDIA, 2024)everyday tasks in procedurally varied kitchensa common test bed for household skills
RoboTwin 2.0 (University of Hong Kong and others, 2025)50 two-arm tasks on five robots, with clutter, lighting and table height randomiseda common test for bimanual policies
BEHAVIOR-1K (Stanford, 2022–24)1,000 household activities people said they want help withlong activities remain hard for every method

Every simulated score carries its simulator's reality gap, and every fixed benchmark is eventually learned rather than solved: LIBERO-PRO and LIBERO-Plus (2025) found models scoring above 90% that ignored nonsense instructions. Video world models can rank policies and find failures, but not yet certify them.

Real-world protocols

The checklist of Robot data at scale — success defined in advance, interleaved trials, blinded scoring, a taxonomy of failures — is now standard in careful papers, and two 2025 systems scale it up. RoboArena spreads evaluation over seven universities with the same DROID set-up: an evaluator picks a task, runs two anonymous policies and says which did better, and the preferences are aggregated into a ranking, as in the leaderboards of Evaluating models. AutoEval (UC Berkeley) builds cells that reset their own scenes and detect success automatically, so submitted policies are evaluated around the clock; its results tracked human-run evaluations closely. Competitions, from RoboCup@Home to Beijing's World Humanoid Robot Games (August 2025), test robots away from their makers' labs, but a medal is one attempt at a known task, not a reliability estimate.

Deployment metrics and demonstrations

Deployment replaces the success rate with measures of a working system: throughput compared with the process it replaces; interventions per hour, every time a person must step in on site or remotely (the counterpart of the disengagement reports California requires of self-driving testers); mean time between failures; availability; and incidents weighted by severity, near misses included. Published figures are rare, and that scarcity is itself information.

A video proves that something happened once. Ask: was the robot autonomous, and if not, who was in the loop? Is it at 1× speed? How many takes? At Tesla's "We, Robot" event in October 2024, Optimus robots served drinks to guests; Bloomberg and others reported that people were remotely operating much of what they did. Many labs now caption videos "autonomous, 1×" or say which parts were teleoperated, a practice worth rewarding.

ComputationC

Statistical rigour: how sure can we be?

Robot data at scale introduced the Wilson interval and showed how many trials it takes to tell a 70% policy from an 80% one. Deployment asks harder questions: which interval to trust near 100%, how small a failure rate testing can demonstrate, and what happens when trials are not independent. The first program reports six tasks with Wilson intervals, computes exactly how often each kind of interval contains the true rate, and bounds rare failures.

python
from math import ceil, comb, log, sqrt

def wilson(k, n, z=1.96):
    """95% Wilson score interval for k successes in n trials."""
    p = k / n
    centre = (p + z * z / (2 * n)) / (1 + z * z / n)
    half = z * sqrt(p * (1 - p) / n + z * z / (4 * n * n)) / (1 + z * z / n)
    return max(0.0, centre - half), min(1.0, centre + half)

def wald(k, n, z=1.96):
    """The textbook interval p +/- z sqrt(p (1 - p) / n)."""
    p = k / n
    half = z * sqrt(p * (1 - p) / n)
    return p - half, p + half

# One generalist policy on six tasks, as a lab might report it.
results = {"pick unseen objects": (46, 50), "open a drawer": (41, 50), "wipe the table": (33, 50),
           "fold a towel": (18, 50), "load a dishwasher": (9, 20), "hang a mug": (20, 20)}
print("task                 result   95% Wilson interval")
for task, (k, n) in results.items():
    lo, hi = wilson(k, n)
    print(f"{task:20s} {k:3d}/{n:<3d}   {lo:.2f} to {hi:.2f}")

def coverage(interval, p, n):
    """Exact probability, over every possible outcome k, that the interval contains the true p."""
    return sum(comb(n, k) * p ** k * (1 - p) ** (n - k)
               for k in range(n + 1) if interval(k, n)[0] <= p <= interval(k, n)[1])

print("\ntrue rate   coverage at n = 20:  Wald   Wilson   (should be 95%)")
for p in (0.5, 0.8, 0.9, 0.95, 0.99):
    print(f"   {p:.2f}   {coverage(wald, p, 20):24.1%}   {coverage(wilson, p, 20):6.1%}")

def upper_bound(f, n, alpha=0.05):
    """Exact (Clopper-Pearson) one-sided 95% upper bound on the failure rate after f failures in n trials."""
    cdf = lambda q: sum(comb(n, i) * q ** i * (1 - q) ** (n - i) for i in range(f + 1))
    lo, hi = 0.0, 1.0
    for _ in range(60):                    # bisection for the q at which f or fewer failures has probability alpha
        mid = (lo + hi) / 2
        lo, hi = (mid, hi) if cdf(mid) > alpha else (lo, mid)
    return hi

print("\nfailures in 300 trials   95% upper bound on the failure rate")
for f in (0, 1, 3):
    q = upper_bound(f, 300)
    print(f"{f:22d}   {q:.4f}  (1 in {1 / q:.0f})")

print("\nfailure-free trials needed to show a failure rate below q (95% confidence):")
for q in (1e-2, 1e-3, 1e-4):
    n = ceil(log(0.05) / log(1 - q))
    print(f"  q = {q:<6g} {n:6d} trials = {n * 2 / 60:5.0f} robot-hours at 2 minutes a trial")
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

Read the intervals before the percentages. "Hang a mug: 20/20" means a success rate somewhere above 84%; "load a dishwasher: 9/20" is consistent with anything from 26% to 66%. The textbook (Wald) interval should never be used for robots: at a true rate of 95% it contains the truth only 63.9% of the time, and at 99% only 18.2%, because whenever all 20 trials succeed it reports the absurd interval from 1 to 1. Wilson stays between 92.5% and 98.3%.

Rare failures are where testing runs out. Zero failures in 300 trials bounds the failure rate below 1 in 101: the rule of three, q≲3/nq \lesssim 3/n, from (1−q)n≤e−qn(1-q)^n \le e^{-qn} and e−3≈0.05e^{-3} \approx 0.05 (Autonomous vehicles met its Poisson form). Fewer than one failure in 10,000 needs 29,956 consecutive successes, about 1,000 robot-hours, and strictly again after every software update. Nobody does that for each release, which is why the case for deploying a learned robot rests on the architecture of the next section, not on testing alone.

Independence is the other weak point: trials in the same kitchen, with the same objects and light, succeed or fail together. In the second program each scene has its own success rate, drawn from a distribution with mean 80%, and 100 trials are split across scenes in four ways.

python
import numpy as np
from math import sqrt

def wilson(k, n, z=1.96):
    p = k / n
    centre = (p + z * z / (2 * n)) / (1 + z * z / n)
    half = z * sqrt(p * (1 - p) / n + z * z / (4 * n * n)) / (1 + z * z / n)
    return centre - half, centre + half

# Success depends on the scene (kitchen, lighting, objects), not only on luck. Across all the scenes
# the robot might meet, the per-scene success rate follows a Beta(4, 1) distribution: mean 0.80.
rng = np.random.default_rng(42)
a, b = 4.0, 1.0
truth = a / (a + b)
icc = 1 / (a + b + 1)                    # correlation between two trials in the same scene

print("100 trials as scenes x trials   naive Wilson interval contains 0.80   effective n")
for scenes, per in [(5, 20), (10, 10), (25, 4), (100, 1)]:
    hits = 0
    for _ in range(4000):                 # 4000 independent evaluation campaigns
        p_scene = rng.beta(a, b, size=scenes)
        k = int(rng.binomial(per, p_scene).sum())
        lo, hi = wilson(k, scenes * per)  # pretends the 100 trials are independent
        hits += lo <= truth <= hi
    n_eff = scenes * per / (1 + (per - 1) * icc)
    print(f"        {scenes:3d} x {per:<3d}              {hits / 4000:20.1%}           {n_eff:6.1f}")
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

As 5 scenes of 20 trials, the naive Wilson interval contains the true 80% in only 64.7% of campaigns: those 100 trials carry about as much information as 24 independent ones. The design effect 1+(m−1)ρ1 + (m-1)\rho, for mm trials per scene and correlation ρ\rho between outcomes in one scene, measures the loss; spread over 100 scenes, the same budget recovers nearly nominal coverage. So count scenes as well as trials, analyse per scene (scene means, or a bootstrap that resamples whole scenes), and report both numbers.

DefinitionsH

Safety filters and runtime monitors

Testing cannot bound how rarely a learned policy fails, so deployed systems do not ask the policy to be safe. They surround it with components whose behaviour can be analysed: a safety filter that checks each command against a model and changes it as little as possible; a runtime monitor that notices when the policy is out of its depth and hands over to a fallback; and beneath both, the safety-rated layer of Embedded control and functional safety. Lui Sha's simplex architecture (2001) had the same shape: an unverified high-performance controller, with a simple verified one ready to take over.

observationscameras, instruction, statelearned policya VLA: no guaranteessafety filterCBF, reachability, MPCcontroller, drivestracks the commandsruntime monitornovelty, progressfallbackstop, safe pose, askrobotpeople nearbyalarmsafety-rated layer: safety controller, e-stop, speed and separation monitoring, safe torque offindependent of all the software above itnew observationsremoves motor power
Defence in depth around a learned policy. The policy proposes; a model-based filter corrects; a monitor can switch to a fallback; and a certified, hard-wired layer can stop the machine whatever the software above it does.

Definition— Control barrier function

Take a system x˙=f(x)+g(x) u\dot x = f(x) + g(x)\,u with inputs uu in an admissible set UU, and a safe set C={x:h(x)≥0}\mathcal C = \{x : h(x) \ge 0\} for a continuously differentiable function hh. Then hh is a control barrier function (CBF) with rate α>0\alpha > 0 if at every x∈Cx \in \mathcal C some u∈Uu \in U satisfies

h˙(x,u)=∇h(x)T(f(x)+g(x) u)  ≥  −α h(x).\dot h(x, u) = \nabla h(x)^{\mathsf T}\big(f(x) + g(x)\,u\big) \;\ge\; -\alpha\, h(x).

The CBF safety filter replaces the policy's command unomu_{\text{nom}} by the solution of the quadratic programme u∗=arg⁡min⁡u∈U∥u−unom∥2u^\ast = \arg\min_{u \in U} \lVert u - u_{\text{nom}} \rVert^2 subject to that inequality.

Theorem— A barrier function keeps the safe set invariant

Suppose the closed loop has a solution x(t)x(t) with h(x(0))≥0h(x(0)) \ge 0, and the applied inputs satisfy h˙≥−αh\dot h \ge -\alpha h along it. Then h(x(t))≥h(x(0)) e−αt≥0h(x(t)) \ge h(x(0))\,e^{-\alpha t} \ge 0 for all t≥0t \ge 0: the system never leaves C\mathcal C.

Proof

Let ϕ(t)=eαt h(x(t))\phi(t) = e^{\alpha t}\, h(x(t)). Then ϕ˙=eαt (h˙+αh)≥0\dot\phi = e^{\alpha t}\,(\dot h + \alpha h) \ge 0, so ϕ\phi never decreases and ϕ(t)≥ϕ(0)=h(x(0))\phi(t) \ge \phi(0) = h(x(0)). Multiplying by e−αte^{-\alpha t} gives the claim.

∎

The theorem never mentions the policy: however bad unomu_{\text{nom}} is, the filtered system stays safe, provided the model (ff, gg, UU) is right and a safe input always exists.

A barrier for a robot that must brake

A mobile base drives along a corridor towards a person, commanded by its acceleration aa, at most 1.0 m/s21.0\ \text{m/s}^2 forwards and −b-b when braking. With dd the gap to a keep-out boundary around the person and vv the closing speed, d˙=−v\dot d = -v and v˙=a\dot v = a. A natural barrier is the gap that would remain after braking to a stop,

h(d,v)=d−max⁡(v,0)22b,h(d, v) = d - \frac{\max(v, 0)^2}{2b},

the protective separation distance of Embedded control and functional safety as a smooth function of the state. For v>0v > 0, h˙=−v−(v/b) a\dot h = -v - (v/b)\,a, so the CBF inequality caps the acceleration: a≤b (αh/v−1)a \le b\,(\alpha h / v - 1). Braking at a=−ba = -b gives h˙=0\dot h = 0, so a safe input exists whenever h≥0h \ge 0, and with one input and one constraint the quadratic programme reduces to taking the smaller of the command and the cap. The program pits a deliberately poor stand-in for a learned policy — aiming 25 cm short of the boundary, but underdamped and noisy — against the filter over 200 random starts, then breaks the filter's assumptions.

python
import numpy as np

DT = 0.01                  # 100 Hz control loop
A_MAX = 1.0                # m/s^2: the most the base will accelerate

def barrier(d, v, b):
    """h(d, v): the gap that would remain after braking at b to a stop. h >= 0 is the safe set."""
    return d - max(v, 0.0) ** 2 / (2 * b)

def safety_filter(a_nom, d, v, b=2.0, alpha=3.0):
    """The acceleration closest to a_nom with dh/dt >= -alpha h: a one-constraint QP, solved in closed form."""
    a = min(a_nom, A_MAX)
    if v > 1e-9:                                   # dh/dt = -v - (v / b) a, so the constraint caps a
        a = min(a, b * alpha * barrier(d, v, b) / v - b)
    return max(a, -b)

def policy(d, v, rng):
    """Stand-in for a learned policy: go to a hand-over point 0.25 m short of the keep-out boundary.
    Underdamped and noisy, so it sometimes overshoots."""
    return 3.0 * (d - 0.25) - 2.0 * v + rng.normal(0, 1.0)

def episode(seed, use_filter=True, b_true=2.0, b_model=2.0, delay=0.0, predict=False):
    rng = np.random.default_rng(seed)
    d, v = rng.uniform(1.5, 4.0), rng.uniform(0.0, 1.0)  # gap to the boundary (m), closing speed (m/s)
    lag = int(round(delay / DT))
    seen = [(d, v)] * (lag + 1)                         # sensor data arrive `delay` seconds late
    sent = []                                           # commands sent since the oldest data in `seen`
    closest = d
    for _ in range(int(6 / DT)):
        d_est, v_est = seen[0]
        if predict:                                     # roll the stale estimate forward with our own commands
            for a_old in sent:
                d_est -= v_est * DT + 0.5 * a_old * DT * DT
                v_est += a_old * DT
        a = policy(d_est, v_est, rng)
        if use_filter:
            a = safety_filter(a, d_est, v_est, b=b_model)
        a = float(np.clip(a, -b_true, A_MAX))           # what the wheels can really deliver
        d -= v * DT + 0.5 * a * DT * DT
        v += a * DT
        seen = seen[1:] + [(d, v)]
        sent = (sent + [a])[-lag:] if lag else []
        closest = min(closest, d)
    return closest, d

cases = [("no filter", dict(use_filter=False)),
         ("filter, model correct", dict()),
         ("filter, wet floor brakes at 1.2 not 2.0", dict(b_true=1.2)),
         ("filter, state arrives 0.2 s late", dict(delay=0.2)),
         ("both faults; filter assumes 1.2, predicts lag", dict(b_true=1.2, delay=0.2, b_model=1.2, predict=True))]
print("set-up                                         crossed   closest approach   mean final gap")
for label, kw in cases:
    runs = np.array([episode(seed, **kw) for seed in range(200)])
    print(f"{label:46s} {np.mean(runs[:, 0] < 0):6.1%}   {runs[:, 0].min() * 100:+10.1f} cm   {runs[:, 1].mean() * 100:9.1f} cm")
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

Without the filter the policy crosses the boundary in 59.5% of episodes, by up to 23.6 cm. With the filter and a correct model it never crosses, and the mean final gap hardly changes (29.9 cm against 30.8 cm): the filter acts only near the edge of the safe set. Then the guarantee breaks exactly where its assumptions do. On a wet floor that brakes at 1.2 instead of 2.0 m/s², the filtered robot crosses more often than the unfiltered one, in 71% of episodes, because the filter confidently allows speeds the floor cannot stop. With state information 0.2 s old it crosses in 58%. A filter that assumes the worst-case braking and predicts the present state from its own recent commands is safe again under both faults, at no visible cost to the task.

123012gap to the keep-out boundary, d (m)closing speed, v (m/s)unsafe, h < 0:cannot stop in timebetween the curves: safe for the model,unsafe on a wet floorsafe set, h ≥ 0startstops at d = 0.25 mh = 0 with the assumed braking, 2.0 m/s²h = 0 on a wet floor, 1.2 m/s²a filtered trajectory
The filter's world, for b = 2.0 m/s². States left of the solid curve cannot stop before the boundary. A filtered trajectory (sketched) speeds up, then slides down outside the curve to the hand-over point. Between the curves lie states safe for the model but not on a wet floor.

Other safety filters follow the same check-and-correct pattern (Hsu, Hu and Fisac's 2024 review unifies them): Hamilton–Jacobi reachability computes the largest set from which safety can be kept despite bounded disturbances, at a cost exponential in the state dimension, and predictive safety filters use MPC to check that a backup plan to a safe state still exists.

Runtime monitors

A filter protects against what its model describes: collisions, speeds, forces. It cannot tell that the policy is about to put a metal bowl in the microwave. Runtime monitors watch for the policy being out of its depth — unfamiliar inputs, sampled actions that disagree, a task that has stopped progressing — and trigger the fallback. Their hardest design question is the alarm threshold, and conformal prediction answers half of it.

Definition— Split conformal threshold

Let s1,…,sns_1, \dots, s_n be a monitor's scores on held-out runs from the conditions it should accept, s(k)s_{(k)} the kk-th smallest, and k=⌈(n+1)(1−ε)⌉k = \lceil (n+1)(1-\varepsilon) \rceil (at most nn). If a new run's score is exchangeable with the calibration scores (for example, all are independent draws from one distribution), then raising an alarm when s>s(k)s > s_{(k)} has false-alarm probability at most ε\varepsilon, whatever that distribution is.

The program calibrates a monitor whose score is the disagreement among action chunks sampled from the policy. The score distributions are invented; the calibration works for any of them.

python
import numpy as np

rng = np.random.default_rng(0)

# The monitor's score: how much 8 action chunks, sampled from the policy for the same observation,
# disagree (higher = less sure). Its distribution in each condition is made up for illustration;
# the calibration below works the same whatever the distribution is.
CONDITIONS = {                          # log-normal parameters of the score
    "familiar scenes":           (0.0, 0.4),
    "familiar, evening light":   (0.2, 0.4),
    "unseen object":             (0.5, 0.5),
    "camera knocked 5 cm":       (1.0, 0.5),
    "confidently wrong":         (0.0, 0.4),   # ignores the instruction but is sure of itself
}
def scores(condition, n):
    mu, sigma = CONDITIONS[condition]
    return np.exp(rng.normal(mu, sigma, n))

# Split conformal calibration: 200 held-out runs in familiar scenes, target false-alarm rate 5%.
eps, n_cal = 0.05, 200
k = int(np.ceil((n_cal + 1) * (1 - eps)))          # use the k-th smallest calibration score
tau = np.sort(scores("familiar scenes", n_cal))[k - 1]
print(f"threshold = calibration score number {k} of {n_cal}: {tau:.3f}")
for condition in CONDITIONS:
    print(f"  {condition:25s} flagged {np.mean(scores(condition, 20000) > tau):6.1%}")

# The guarantee holds on average over calibration sets, for data exchangeable with them.
far = []
for _ in range(2000):
    t = np.sort(scores("familiar scenes", n_cal))[k - 1]
    far.append(np.mean(scores("familiar scenes", 2000) > t))
far = np.array(far)
print(f"\nover 2000 calibrations: mean false-alarm rate {far.mean():.2%} (theory {1 - k / (n_cal + 1):.2%}),"
      f" middle 90% from {np.percentile(far, 5):.1%} to {np.percentile(far, 95):.1%}")
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

Averaged over 2,000 calibration sets the false-alarm rate is 5.02%, against a theoretical 4.98%, though one calibration set gives anywhere from 2.6% to 7.9% (the first gave 5.6%). The monitor flags 39.5% of runs with an unseen object and 76.6% after a knocked camera. Two rows show its limits. Evening light was not in the calibration data, so false alarms nearly triple, to 14.1%: the guarantee needs exchangeability. And the confidently wrong policy — the LIBERO studies' failure, a memorised motion executed whatever the instruction — is flagged no more often than a normal run, because its uncertainty is normal. Conformal calibration controls false alarms; it promises nothing about detection.

So monitors combine signals. Sentinel (Stanford and NVIDIA, 2024) pairs the consistency of a diffusion policy's samples with a vision-language model judging task progress, and catches more failures than either alone. Conformal methods also tell language-model planners when to ask for help (Ren and colleagues, 2023), and Google DeepMind's ASIMOV benchmark (2025) tests whether models recognise semantically unsafe instructions.

ExplanationH

Standards and regulation, as of November 2026

Embedded control and functional safety described the standards that show a conventional robot is safe enough to sell, and Humanoid robots the gap for robots that must balance. Learned behaviour strains that system, whose methods assume software that can be specified and tested against its specification. The European Union has gone furthest in law, so it is the worked example here: a general description, dated, not legal advice.

The Machinery Regulation, (EU) 2023/1230, replaces the Machinery Directive and applies directly in every member state from 20 January 2027. Safety components and machinery with "fully or partially self-evolving behaviour using machine learning approaches" that ensure safety functions need a third-party conformity assessment by a notified body, not just the maker's own declaration. Control systems with such behaviour must not act beyond their defined task and movement space, must be correctable at any time, and must record data on their safety-related decisions. The regulation also covers protection against corruption and malicious attacks, the psychological stress of working with machines, and autonomous mobile machinery, which needs a remote supervisor able to stop it.

The AI Act, (EU) 2024/1689, regulates AI by risk. An AI system that is a safety component of a product under EU product law, machinery included, is "high-risk", with requirements on risk management, data governance, logging, transparency, human oversight, and accuracy, robustness and cybersecurity. In July 2026 the "digital omnibus on AI" postponed the high-risk obligations and changed how machinery is handled: the Commission must instead write equivalent requirements into the Machinery Regulation's own essential requirements, by delegated acts applying by 2 August 2028. And the revised Product Liability Directive treats software, AI included, as a product, so a defective learned policy can make its maker liable without proof of fault.

DateMilestone in EU law
1 August 2024AI Act in force (bans from February 2025, general-purpose model rules from August 2025)
27 July 2026digital omnibus on AI, Regulation (EU) 2026/1744, in force
December 2026revised Product Liability Directive applies to new products
20 January 2027Machinery Regulation applies; Machinery Directive repealed
2 December 2027AI Act high-risk obligations for stand-alone uses, including worker management
2 August 2028AI Act high-risk obligations for AI in regulated products; AI requirements written into the Machinery Regulation apply

Elsewhere, approaches differ. The United States has no federal AI or robot statute: OSHA covers workplace safety, robot standards are adopted as ANSI/A3 R15.06, NIST's AI Risk Management Framework is voluntary, and states pass their own AI laws. China works through national standards, with a ministry committee for humanoid and embodied-AI standards since the end of 2025. Japan's AI Promotion Act (May 2025) relies on guidance; South Korea's AI Basic Act took effect in January 2026. Standards such as ISO/IEC TR 5469 (2024), ISO/PAS 8800 (2024) for road vehicles and UL 4600 bridge AI and functional safety.

They converge on the safety case, a structured, evidenced argument that a system is acceptably safe for a defined use. For a learned robot its evidence is this lesson's material: honest intervals, a filter with measured parameters, a calibrated monitor, and a safety-rated layer that depends on none of them.

ExplanationH

People around learned robots

Three findings from human–robot interaction (HRI) research matter for every deployment.

Motion is communication. Anca Dragan, Kenton Lee and Siddhartha Srinivasa (2013) distinguished predictable motion, which matches what an observer expects given the goal, from legible motion, which lets an observer infer the goal quickly. A policy trained to imitate demonstrations optimises neither, yet people beside a robot plan their movements around what they think it will do. Deployed robots add explicit signals: lights, sounds, paths projected on the floor, a pause before moving.

People overtrust robots. In a 2016 Georgia Tech study, participants in a simulated fire emergency followed a guide robot even when they had just watched it navigate badly. The AI Act's human-oversight requirement names automation bias explicitly: a supervisor who approves whatever the machine proposes is not oversight. Interfaces should show what the robot is about to do and how sure it is, and make stopping or correcting it easy.

Autonomy usually includes people. 1X's NEO can be taken over by a remote operator in sessions its owner schedules (Humanoid robots); robotaxis call remote assistance when stuck; warehouse staff resolve stuck picks from a screen. That is honest engineering, and it raises questions: who sees inside the home, where the operators work and on what terms, and whether bystanders — shoppers, patients, a family's guests, none of whom chose the robot — know a person may be watching.

ExplanationH

Work and labour

The evidence on what conventional industrial robots do to jobs differs by country. In the United States, Daron Acemoglu and Pascual Restrepo (2020) found that in local labour markets more exposed to robots between 1990 and 2007, one more robot per thousand workers reduced the employment-to-population ratio by about 0.2 percentage points and wages by about 0.42%. In Germany, Wolfgang Dauth and colleagues (2021) found no loss of total employment: manufacturing jobs lost were offset in services, mostly through fewer young people entering manufacturing rather than dismissals. In Japan, Daisuke Adachi, Daiji Kawaguchi and Yukiko Saito (2024) found that falling robot prices from 1978 to 2017 raised employment in adopting industries, through higher productivity and output. Across 17 countries, Georg Graetz and Guy Michaels (2018) found higher labour productivity and no significant fall in total hours, but a smaller share of hours for low-skilled workers. Effects depend on institutions and on whether robots expand output or only replace labour, and the costs fall hardest on particular workers in particular places.

Those studies concern robots programmed for fixed tasks. Learned robots aim at work that resisted automation because it varied — mixed picking, laundry, helping care staff — and no one knows how fast they will spread: in 2026 they work in pilots of a few robots each, against about half a million conventional industrial robots installed a year. Forecasts with precise job numbers for 2030 deserve the scepticism due to a success rate without a sample size.

Learned robots also run on human labour that is easy not to see: teleoperators recording demonstrations for whole shifts, annotators, remote supervisors, often in another country from the robot. And workers have a voice when they organise: automation was central to the October 2024 strike by the International Longshoremen's Association at US East and Gulf Coast ports, and the contract agreed in January 2025 restricted fully automated equipment. Engineers shape the outcome too: a robot can take the heavy lifting and leave the judgement to a person, or set the pace a person must keep.

Optional Christian reflection · Work that dignifies

A reflection from the Christian tradition that inspires Lumenary Academy. It is not part of the mathematics and you are welcome to skip it.

In the Bible, work comes before any curse: "the LORD God took the man, and put him into the garden of Eden to dress it and to keep it" (Genesis 2:15, King James Version). Christians have drawn from this that work belongs to human dignity and is not merely a cost. The Reformers taught that the farmer's and the servant's work is a calling as holy as the priest's; Leo XIII's Rerum Novarum (1891) defended fair wages and workers' right to organise; John Paul II's Laborem Exercens (1981) argued that work exists for the person, not the person for the work. In May 2025 Pope Leo XIV explained his choice of name by pointing to Leo XIII and to a new industrial revolution brought by artificial intelligence. A question for anyone who builds robots, whatever their faith: does this machine take away the work that breaks people and leave them the work that makes them more fully human, or the reverse?

Common misconceptionsH

Common misconceptions

Misconception

"It succeeded in every trial, so it doesn't fail." Twenty successes in twenty trials put the success rate only above 84%; 300 failure-free trials put the failure rate only below 1%. Testing cannot rule out rare failures, which is why deployments rely on filters, monitors and a safety-rated layer.

Misconception

"A safety filter makes any policy safe." It makes a policy safe with respect to its model. Assuming 2.0 m/s² of braking on a floor that gave 1.2, this lesson's filtered robot crossed the boundary more often than the unfiltered one.

Misconception

"A good enough learned policy can be the safety function." Safety functions run on safety-rated hardware with verifiable logic, and in the EU a machine-learning component that ensures a safety function needs a notified body's assessment. Learned components propose; independent, verifiable ones guarantee.

Misconception

"An uncertainty monitor catches failures." It catches unfamiliar situations. A confidently wrong policy scores as normal, and a conformal threshold guarantees the false-alarm rate, never the detection rate.

Misconception

"The rules for AI in robots are settled." The EU moved its high-risk dates in July 2026, the harmonised standards are still being written, and other countries take different approaches. Check the current texts and their dates.

Further reading

Where to go from here

This is the last lesson of Lumenary Robotics: from a first moving robot, through frames, feedback, estimation, planning, hardware and learning, to the open problems of 2026. Its durable lesson is a habit of mind: ask how a claim was measured, what a guarantee assumes, and who is affected when it fails. Keep building, in simulation and with small, slow, battery-powered robots; contribute to open projects such as ROS 2, MuJoCo and LeRobot; and build robots that put the people around them first.

Exercises

Exercises

1. Evaluation, safety and deployment of learned robots

Warm-upHuman

A policy succeeds in all 30 of 30 trials. When every trial succeeds, the lower end of the 95% Wilson interval simplifies to n/(n+z2)n/(n + z^2) with z=1.96z = 1.96. What is that lower bound, in percent, to the nearest whole number?

2. Evaluation, safety and deployment of learned robots

Warm-upHuman

A company announces: "Our humanoid now folds laundry reliably," with a video. Which additional information would make the claim checkable? Select all that apply.

Choose all that apply

3. Evaluation, safety and deployment of learned robots

CoreHuman

An evaluation runs 8 scenes × 15 trials (120 trials in all). Outcomes within a scene are correlated with ρ=0.2\rho = 0.2. Using the design effect 1+(m−1)ρ1 + (m - 1)\rho, how many independent trials is the campaign worth? Round to the nearest whole number.

4. Evaluation, safety and deployment of learned robots

CoreComputational

Write trials_needed(q, failures_allowed=0, confidence=0.95): the smallest number of trials nn such that seeing at most ff = failures_allowed failures in nn trials demonstrates, at the given confidence, that the failure rate is below q. In symbols: the smallest nn with P(X≤f)≤1−confidenceP(X \le f) \le 1 - \text{confidence} for X∼Binomial(n,q)X \sim \text{Binomial}(n, q). Use math.comb for the binomial probabilities. The starter uses the rule of three, which is close but not exact.

Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

5. Evaluation, safety and deployment of learned robots

StretchComputational

Implement the lesson's safety filter as filter_accel(a_nom, d, v, b=2.0, alpha=3.0, a_max=1.0). A base closes on a keep-out boundary: d is the gap (m), v the closing speed (m/s, positive towards the boundary). With the barrier h=d−max⁡(v,0)2/(2b)h = d - \max(v, 0)^2/(2b), return the acceleration closest to a_nom that lies in [−b,amax][-b, a_\text{max}] and satisfies h˙≥−αh\dot h \ge -\alpha h. For v>0v > 0, h˙=−v−(v/b) a\dot h = -v - (v/b)\,a; for v≤0v \le 0 there is no constraint beyond the actuator limits.

Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

6. Evaluation, safety and deployment of learned robots

CoreHuman

A runtime monitor's alarm threshold was set by split conformal calibration on 500 runs in a warehouse during the day, with ε=0.02\varepsilon = 0.02. Which statement is correct?

Choose one

7. Evaluation, safety and deployment of learned robots

CoreHuman

Which statements about EU law are correct as of November 2026? Select all that apply.

Choose all that apply

8. Evaluation, safety and deployment of learned robots

CoreHuman

Each robot in a fleet needs remote help on average once every 2 hours, and each intervention takes 6 minutes. To leave slack for bursts of requests, the operator should be busy at most 80% of the time. How many robots can one operator supervise?

Further reading and resources