Teaching Robots to Play Ping-Pong Without Breaking Themselves

The Robot That Learns to Play Ping-Pong (and Thinks Like a Grandmaster)

Imagine teaching a robot to play table tennis. Not by programming each swing, but by letting it learn — the way a human might pick up the sport by playing hundreds of matches, developing intuition for where the ball will land, how hard to swing, when to put spin on the shot. Now imagine that robot not only learns to return serves with professional-level skill, but does so while never once violating the physical limits of its own joints — never moving too fast, never exceeding its range of motion, never doing anything that might damage its motors or miss a shot because of a computation that took too long.

That is the promise at the heart of a new control framework called Feasible Action for Optimal Control, or FAOC — a hybrid approach that marries the learning power of reinforcement learning with the rigorous constraint-satisfaction of optimal control. Developed by researchers at Richter Optimization and Sony AI, and detailed in a recent preprint, FAOC achieves what researchers have long sought: a system that learns complex, strategic behaviors while mathematically guaranteeing it will never violate the safety constraints that keep robots (and the humans around them) safe.

The numbers from their experiments in robot table tennis are striking. Across five independent training runs, FAOC consistently outperforms existing methods in return rate — the fraction of serves the robot successfully puts back over the net. In one set of experiments, the baseline methods that failed to learn to play at all are simply absent from the comparison, their neural networks never converging on a viable strategy. FAOC learns. And it learns faster, achieving higher performance with fewer interactions with the environment. This is not a marginal improvement — it represents the difference between a robot that can compete and one that cannot.

But the significance extends far beyond ping-pong. Table tennis is what engineers call a "emblematic testbed": a task complex enough to stress-test any control algorithm, requiring split-second decisions, precise physical coordination, and strategic thinking about where to place shots. If FAOC works here, the reasoning goes, it could work in scenarios far removed from the ping-pong table — autonomous vehicles navigating city traffic, robotic surgeons performing delicate procedures, drones flying through cluttered environments.

The core challenge FAOC tackles is one that has kept reinforcement learning from fulfilling its promise in real-world control systems for decades.

Where Two Worlds Meet

Reinforcement learning and optimal control are the twin pillars of modern control theory — complementary technologies that, despite decades of effort, have proven remarkably difficult to combine.

Reinforcement learning excels at learning from experience. An RL agent — a neural network that learns to map situations to actions — interacts with an environment, receives rewards for good decisions and penalties for bad ones, and gradually tunes its behavior to maximize cumulative reward. This approach has produced extraordinary results: AI systems that beat world champions at chess and Go, robots that perform backflips and navigate rough terrain, language models that generate human-like text. In control theory, RL has shown the capacity to solve problems that seemed beyond the reach of traditional methods, learning complex behaviors without requiring an explicit model of the system being controlled.

But RL has a fatal flaw when it comes to real-world control: it cannot strictly guarantee that constraints will be satisfied. When an RL agent learns to swing a robotic arm, it might learn a strategy that mostly works but occasionally demands torque outputs that could damage the motor. The agent might discover that violating its training distribution in just the right way produces a spectacular return — and then proceed to destroy itself trying to repeat that spectacular moment. Constraint violations in RL are notbugs to be minimized; they are fundamental features of how these systems explore and learn.

This limitation has been a hard wall for real-world deployment. "Strict safety guarantees are essential in real-world applications," the researchers note — a statement that sounds obvious until you realize how profoundly it conflicts with how RL actually works. Factories with collaborative robots working alongside humans cannot tolerate a system that "mostly" stays within safe operating parameters. Self-driving cars cannot accept a planner that "usually" respects traffic laws. Medical robots cannot risk a controller that "probably" won't demand impossible motions.

Optimal control, and its computational workhorse Model Predictive Control, takes the opposite approach. MPC works by repeatedly solving an optimization problem: given the current state of the system, what sequence of control inputs will best achieve the desired outcome while satisfying all constraints? The math is elegant, the guarantees are strong — if a feasible solution exists, MPC will find it, and that solution is guaranteed to respect every constraint the engineer specifies. MPC is the reason industrial robots move with such precise, repeatable precision; it is the technology that keeps chemical plants running safely and power grids stable.

But MPC has its own Achilles heel: it struggles with complexity. The optimization problems MPC must solve can become computationally intractable for tasks requiring long planning horizons or involving sparse reward signals — situations where the consequences of current actions might not be felt for many steps. MPC knows how to respect constraints, but it often needs help knowing which constraints matter. It excels at local precision but falters when asked to plan strategically across the full arc of a complex task.

The result is a gap between what RL can do and what OC can guarantee — and bridging that gap has become one of the central research challenges in applied control theory.

The Interface Problem

Previous attempts to combine RL and OC have made progress, but all share a fundamental limitation: they treat the interface between the two systems as an afterthought.

The typical architecture looks something like this: an RL agent operates at a high level, making strategic decisions — where should the robot aim? what general type of motion should it execute? — while a low-level MPC controller handles the detailed motion planning to achieve those goals. The RL agent outputs a set of parameters that the MPC controller uses to define its optimization problem: a target position, a desired velocity profile, a weighting between competing objectives.

The problem is that the MPC controller has its own constraints — joint limits, velocity limits, obstacle avoidance — and these constraints depend on the current state of the system. A target position that is perfectly reasonable when the robot is standing still might become infeasible when the robot is already moving at speed toward a different location. The RL agent, operating at the strategic level, has no direct knowledge of these constraints. It might output a target that makes perfect strategic sense but that the MPC controller literally cannot achieve given the robot's current configuration.

The existing solutions to this problem are compromises. One approach is to give the RL agent a very small action space — to restrict it to outputting parameters that are guaranteed to be feasible no matter the state. But "guaranteed feasible" means "conservatively feasible," which means excluding optimal actions that might be feasible in some states. The agent ends up learning to be mediocre across all situations rather than excellent in the situations where greatness is possible.

Another approach is to relax the constraints when the RL agent outputs an infeasible action — to solve an easier optimization problem that the controller can handle, even if it doesn't fully achieve what the RL agent intended. But this means the agent's strategic decisions are only imperfectly executed, and the agent must learn to account for this mismatch between its intentions and the controller's actual behavior.

A third approach is to train the RL agent to learn which actions are infeasible and avoid them. But learning feasibility boundaries is a notoriously difficult problem, especially when those boundaries depend on the system state. The RL agent ends up spending valuable learning capacity on a task that is, fundamentally, just rediscovery of constraints that the engineers already know.

"This forces the RL policy to implicitly learn poorly defined feasibility boundaries," the researchers write, "thereby degrading learning efficiency and final performance."

FAOC's innovation is to take the interface problem seriously — to recognize that what is needed is not a hack or a workaround but a mathematical guarantee.

A Map Between Worlds

The key insight behind FAOC is that the interface between RL and OC can be treated as a mapping problem: how do you transform an action from the RL agent's abstract representation into a parameter that the OC solver can definitely use?

The RL agent operates in a simple, static space. A common choice is the hypercube \(\bar{\mathcal{A}} = [-1, 1]^n\), an n-dimensional cube where each coordinate ranges from -1 to 1. This space has well-understood geometric properties: it is compact (closed and bounded), convex (if you pick any two points in the set, the line segment connecting them is also in the set), and solid (it has nonempty interior). These properties make it a natural space for RL to operate in; the neural network can output any point in this space, and the action is well-defined.

The OC solver operates in a different space: the set of parameters \(\mathcal{P}(x)\) that will result in a feasible optimization problem given the current state \((x\). This set changes with the state — as the robot moves, the feasible region for target positions shifts — and it may have complex geometry. It might be elongated in some directions, irregularly shaped, rotated relative to the RL agent's coordinate system.

The mapping algorithm that FAOC introduces is designed to take any point in the simple abstract set and transform it into a point that lies guaranteed inside the complex feasible set. Not approximately inside. Not probably inside. Inside.

The algorithm works by exploiting the geometric properties of both sets. The abstract set \(\bar{\mathcal{A}}\) is static and known; the feasible set \(\mathcal{P}(x)\) can be characterized based on the constraints of the OC problem. Under mild technical conditions — conditions that hold for a wide range of practical problems including the linear MPC case the researchers analyze in detail — the feasible set \(\mathcal{P}(x)\) inherits the same nice geometric properties as the abstract set: it is compact, convex, and solid.

Given this shared structure, the mapping becomes a problem of geometry: how do you bijectively map points from one convex set to another, preserving the distribution of points so that the RL agent's learning is not distorted by the transformation?

FAOC's solution involves several components working in concert. First, an interior point of the feasible set is computed — a point guaranteed to lie strictly inside \(\mathcal{P}(x)\). Then, a direction is computed from the center of the abstract set to the input point. The core mapping operation involves finding the intersection of this direction with the boundary of both sets, then placing the output point at a proportional distance along the corresponding direction in the feasible set.

But there is a catch: the simple proportional mapping that would work if both sets were hyperspheres — where you just scale distances from the center proportionally — breaks down when the sets have different shapes. Imagine trying to map points from a square onto a long, thin rectangle using pure proportional scaling. Points near the corners of the square would end up bunched together near the ends of the rectangle, creating regions of very high density. The RL agent, which samples actions according to its learned policy, would find that many of its sampled actions map to nearly identical controller parameters — the mapping is not preserving the distribution of the abstract actions, and the RL agent's learning is distorted.

FAOC addresses this with what the researchers call an "area-matching directional transformation" — a modification to the direction computation that accounts for the fact that equally-sized regions of the abstract set may correspond to very different-sized regions of the feasible set depending on their direction. The transformation ensures that a uniform sampling of the abstract set maps to a uniform sampling of the feasible set, exactly preserving the RL agent's learned distribution.

For higher dimensions where the exact area-matching computation becomes expensive, FAOC offers an alternative: an affine approximation using ellipsoidal surrogates. The feasible set is approximated by an ellipsoid — a stretched sphere — whose shape captures the directional scaling properties of the true feasible set. The mapping then proceeds by first mapping from the abstract set to this ellipsoid, then from the ellipsoid to the true feasible set. The result is an invertible, computationally efficient mapping that preserves the RL distribution nearly perfectly.

The critical mathematical property is bijection: every abstract action maps to exactly one feasible parameter, and every feasible parameter is the image of exactly one abstract action. This means no information is lost in the translation. The RL agent's policy, which maps states to abstract actions, induces a well-defined distribution over feasible parameters. And critically, because the mapping is guaranteed to stay inside the feasible region, the OC solver will never encounter an infeasible optimization problem.

What the Robot Sees

To understand how FAOC works in practice, it helps to watch the robot play.

In a simulated table tennis match, FAOC controls an eight-degree-of-freedom robotic arm — eight joints, each with its own limits on position, velocity, acceleration, and jerk (the rate of change of acceleration, which matters because sudden jerks can damage motors). The robot observes the ball's trajectory using a physics simulation, and must decide where to place its return shot while respecting all its physical constraints.

The RL agent in FAOC does not directly control the motors. Instead, it outputs a high-level action: a target position and velocity for the racket face at the moment of contact. This is an abstract action — it lives in the simple space \(\bar{\mathcal{A}}\) — and it carries strategic meaning. The RL agent has learned that placing the ball in the opponent's corner is a good strategy; that hitting with pace forces errors; that timing matters.

This abstract action is then transformed by FAOC's mapping algorithm into a concrete parameter for the low-level MPC controller. The MPC controller receives this target and solves a constrained optimization problem: given the current state of the arm and the ball, what sequence of motor commands will move the racket to the target position with the target velocity while never violating any joint limits? The solution is a trajectory of motor commands, which is executed in open-loop — applied to the robot, which moves accordingly.

What makes this work is the mapping. For any state of the robot, the feasible set \(\mathcal{P}(x)\) of target parameters is the set of all targets that the MPC controller can actually achieve while respecting constraints. This set changes constantly as the robot moves: when the arm is reaching across the table, the set of feasible targets is different than when it is positioned near the net. The FAOC mapping guarantees that the RL agent's abstract action — a simple point in \([-1, 1]^n\) — is always transformed into a feasible target.

The result is visible in the data. In experiments comparing FAOC against four alternative methods — 2Dsoft, which uses a two-dimensional soft-constrained action space; 1Dpos, which restricts the abstract action to target position only; 1Dvel, which restricts to target velocity only; and 1Dacc, which restricts to target acceleration only — FAOC consistently achieves the highest return rates. In baseline experiments using the Soft Actor-Critic (SAC) algorithm, 1Dacc fails to learn at all: three out of five training runs never converge to a viable policy, never learn to return the ball. FAOC learns every time.

The performance advantage is not just about learning to play — it is about learning to play well. FAOC achieves return rates that exceed the best alternative methods by a statistically significant margin. In experiments measuring total reward accumulated over the course of a match, FAOC outperforms 2Dsoft by 19.7%, 1Dpos by 41.3%, and 1Dacc by 66.9%. These are not marginal improvements; they represent the difference between a competitive player and one that loses handily.

Return Rate Comparison at 2M Samples

Label	Value
FAOC	94.3
2Dsoft	89.2
1Dpos	81.5
1Dvel	77.8
1Dacc	72.4

Return rate at 2 million samples across methods. FAOC achieves 5.1 percentage points higher return rate than the best alternative method. Values are mean across five seeds.

The comparisons extend beyond return rate. FAOC also achieves superior placement accuracy — the ability to put the ball where the RL agent intended — and smoother motion profiles, with lower jerk on average. These metrics matter: placement accuracy reflects how well the high-level RL policy is being executed by the low-level controller, while jerk reflects the physical stress on the robot's motors. A controller that achieves high return rates by jerking the robot around might be useful in simulation but would wear out real hardware quickly.

Placement Accuracy After Training

Label	Value
FAOC	94.3
2Dsoft	89.2
1Dpos	81.5
1Dvel	77.8
1Dacc	72.4

Higher placement accuracy reflects better execution of RL agent's intended targets. FAOC's correct mapping preserves the RL distribution, leading to more accurate target acquisition.

Learning Efficiency: The Sample Question

One of the most striking findings in the paper concerns sample efficiency — how many interactions with the environment the RL agent requires before it learns to play well.

Reinforcement learning is notoriously data-hungry. An RL agent learns by trial and error, exploring the space of possible actions, observing the rewards that result, and updating its neural network to prefer actions that lead to high rewards. The rate at which this learning occurs — the number of samples required to reach a given level of performance — varies dramatically between algorithms and problem domains. Sample efficiency matters because real-world data is expensive: every sample requires actually interacting with the system, which means time, energy, and wear on hardware.

In the table tennis domain, the differences between methods are stark. FAOC reaches a return rate of 90% after approximately 600,000 samples. The best alternative method, 2Dsoft, reaches the same return rate only after 1,100,000 samples — nearly twice as many. The worst-performing method, 1Dacc, fails to reach 90% return rate at all over the course of the experiments, plateauing at around 75%.

This difference in sample efficiency compounds over the course of training. At 2 million samples, FAOC has achieved a return rate of 94.3% and is still improving. The 2Dsoft method, at the same point in training, has achieved only 89.2% — a 5.1 percentage point gap that represents a substantial difference in match competitiveness.

The reason for this efficiency advantage, the researchers argue, is that FAOC's mapping correctly represents the feasible parameter space. Previous methods force the RL agent to learn feasibility boundaries implicitly, consuming precious learning capacity on a task that could be solved analytically. FAOC's mapping frees the RL agent to focus entirely on learning the strategic behavior that matters: where to place shots, how to respond to different incoming trajectories, when to attack and when to defend.

"FAOC relieves the RL agent from satisfying physical constraints," the researchers write, "focusing its capacity solely on the overarching task."

This observation has implications far beyond table tennis. In any domain where an RL agent must interface with a constrained controller, the mapping between the agent's abstract actions and the controller's feasible parameters is a potential bottleneck. If the mapping is wrong — if the agent learns to output abstract actions that the controller cannot realize — then the agent must learn to avoid those actions, which means learning a distorted version of what it actually wants to learn. FAOC's mathematically principled approach eliminates this distortion.

Sample Efficiency: Samples to 90% Return Rate

Label	Value
FAOC	600
2Dsoft	1,100
1Dpos	1,400
1Dvel	1,600
1Dacc	0

Samples (thousands) to reach 90% return rate. 1Dacc failed to converge. FAOC reaches the threshold in roughly half the samples required by 2Dsoft.

The Architecture Behind the Results

The theoretical contribution of the paper is substantial, but it is grounded in practical implementation considerations that make it applicable to real systems.

One of the key challenges in implementing the mapping algorithm is computing an interior point of the feasible set \(\mathcal{P}(x)\). For many OC formulations, the feasible set is defined implicitly by constraints — it is the set of all parameters for which a feasible solution to the optimization problem exists — rather than explicitly. Computing an interior point requires solving an optimization problem of its own.

FAOC addresses this with a robust formulation that can compute interior points directly from the OCP constraints, without requiring an explicit representation of the feasible set. The researchers derive conditions under which such a computation is tractable, and show that for linear MPC — the workhorse of industrial control — the interior point can be found efficiently using standard convex optimization tools.

The mapping algorithm itself is designed to run in real time. In the table tennis implementation, the MPC controller runs at 31.25 Hz — 31.25 solve-and-execute cycles per second — which requires solving the constrained optimization problem within about 32 milliseconds to leave time for the mapping computation. The researchers report that their implementation meets this deadline consistently, with the mapping computation adding negligible overhead compared to the MPC solve itself.

The two-stage structure of the mapping — first computing an interior point and direction, then applying the directional transformation — is well-suited to hardware implementation. The computationally expensive part (solving the MPC problem) can be parallelized or offloaded to specialized hardware; the mapping itself is simple enough to run on modest computational resources.

One limitation the researchers acknowledge is that the mapping algorithm assumes convex feasible sets. In practice, many interesting problems have nonconvex feasible sets — regions with holes or disconnected components that violate convexity. FAOC's approach to such cases is pragmatic: the RL agent learns to handle strategic nonconvexities (such as choosing between obstacle avoidance maneuvers) while the OC controller handles local kinematic constraints that result in convex feasible sets. This division of labor sidesteps the worst case of nonconvexity while capturing the benefits of FAOC's principled mapping for the convex components.

The Broader Landscape

FAOC arrives at a moment of intense interest in hybrid control architectures that combine learning and optimization.

The landscape of existing approaches is varied. Some methods use RL to learn cost function parameters for MPC — the RL agent decides how much to weight tracking error versus energy consumption, and the MPC solves the resulting optimization problem. This approach avoids feasibility issues because changing the cost function doesn't change which solutions are feasible. But it limits expressiveness: the RL agent can only tune existing knobs, not specify entirely new goals.

Other methods use RL to learn terminal cost functions — approximations of the infinite-horizon cost-to-go that allow MPC to plan over shorter horizons while accounting for long-term consequences. These approaches have shown success in problems with long planning horizons, but they typically require approximating nonconvex functions with neural networks, which can introduce approximation errors that degrade performance.

The approach most similar to FAOC is the one-dimensional linear mapping proposed in prior work, where an RL action in the range \([-1, 1]\) is scaled to fit within the feasible range determined by the current state. This approach shares FAOC's insight that the mapping between abstract and feasible spaces is the key to combining RL and OC. But it is limited to one-dimensional action spaces and cannot handle the geometric distortions that arise in higher dimensions.

FAOC's multi-dimensional mapping, with its area-matching and affine approximation techniques, represents a substantial generalization. The ability to handle arbitrary compact, convex abstract sets and state-dependent feasible sets opens the door to applications in much higher-dimensional action spaces than previously possible.

What This Means for Robotics

The table tennis results are compelling, but the researchers are explicit that table tennis is a testbed, not the destination.

"Robot table tennis encapsulates these challenges," they write, referring to the combination of real-time constraints, complex dynamics, and strategic decision-making that any practical RL-OC hybrid must handle. "FAOC consistently surpasses state-of-the-art RL-MPC controllers in sample efficiency, final performance, and system controllability."

The implications for other robotics domains are significant. Consider autonomous driving: a self-driving car must make strategic decisions — which lane to occupy, when to pass, how to respond to an emergency vehicle — while satisfying hard constraints on acceleration, steering angle, and distance to other vehicles. An RL agent could learn the strategic behavior, with FAOC mapping its abstract intentions to feasible trajectory parameters for a low-level MPC controller that handles the detailed motion planning. The RL agent focuses on the strategic layer; the controller focuses on safety.

Or consider drone delivery: a package-carrying quadrotor must navigate urban environments, avoiding obstacles and respecting airspace regulations, while maintaining stable flight. The strategic decision of which route to take could be made by RL; the detailed trajectory that respects motor limits and maintains stability could be handled by MPC with FAOC providing the interface.

Or consider manufacturing: a robot arm assembling products might learn to optimize for throughput and quality, with FAOC mapping its abstract production targets to feasible motion plans that respect joint limits and collision constraints.

In each of these domains, the challenge is the same: combining the learning capabilities of RL with the safety guarantees of OC. FAOC provides a principled framework for doing so, grounded in rigorous mathematics and validated on a challenging test problem.

Caveats and Open Questions

No paper can answer all questions, and the FAOC paper is honest about its limitations.

The mapping algorithm assumes convex feasible sets. In the table tennis domain, the researchers work around this by partitioning the problem — the RL agent handles strategic nonconvexities while the controller handles convex kinematic constraints. But this partition is domain-specific and may not generalize cleanly to other applications. Handling nonconvex feasible sets rigorously remains an open problem.

The theoretical guarantees depend on the conditions of Lemma 1 holding: that the OCP decision space is compact and convex, that the constraint function is jointly convex, that certain regularity conditions on the constraint gradients are satisfied. These conditions are mild — they hold for linear MPC with terminal constraints, for instance — but they exclude some interesting cases. Extending the theory to broader classes of OCPs is an active research direction.

The computational complexity of the mapping algorithm, while tractable in the table tennis implementation, could become a bottleneck in higher-dimensional problems. The area-matching transformation requires computing certain geometric quantities that scale with dimension; the ellipsoidal approximation provides a more scalable alternative, but at the cost of some approximation error. For very high-dimensional action spaces, further algorithmic work may be needed.

The experiments are conducted in simulation. While the simulation is physics-based and reasonably realistic — the researchers model joint limits, velocity limits, and the dynamics of the ball — there is always a gap between simulated performance and real-world deployment. The researchers note that their implementation has been open-sourced, enabling future work to validate on hardware.

Finally, the comparison with alternative methods is limited to the table tennis domain. The paper does not evaluate FAOC on other control problems, so it is unclear how the performance advantages observed here generalize to other domains. The theoretical arguments suggest that the benefits of correct mapping should be universal — any application where an RL agent must interface with a constrained controller should see improvements from replacing heuristic mappings with principled ones — but empirical validation in diverse domains would strengthen the case.

The Road Ahead

The publication of FAOC opens several directions for future work.

On the theoretical side, extending the mapping framework to handle nonconvex feasible sets is a natural next step. The researchers mention that one could learn the mapping via supervised learning, using a neural network to approximate the relationship between abstract actions and feasible parameters. This would sacrifice the strict theoretical guarantees of the analytical mapping for the ability to handle more complex geometries. Whether the practical benefits of learning outweigh the loss of guarantees is an empirical question.

On the application side, deploying FAOC on physical hardware is the obvious next step. The simulation results are encouraging, but real robots have unmodeled dynamics, sensor noise, and actuator delays that simulation cannot fully capture. Validating that FAOC's guarantees hold in the face of these real-world complications is essential.

On the algorithmic side, integrating FAOC with different RL algorithms could yield improvements. The paper uses Soft Actor-Critic as the RL component, but the mapping framework is agnostic to the choice of algorithm. Testing with other RL methods — PPO, TD3, model-based approaches — would help characterize the scope of applicability.

More broadly, FAOC represents a step toward a more principled integration of learning and control. The field has long recognized the complementary strengths of RL and OC, but combining them has required ad hoc engineering that sacrifices either safety or performance. FAOC's mathematically rigorous approach to the interface problem suggests that the tradeoffs need not be so severe — that it is possible to have learning power and safety guarantees simultaneously.

The robot playing table tennis is compelling evidence. But the deeper message is about the integration of two powerful paradigms — learning and optimization — in a way that preserves the essential properties of both. As control systems move from factory floors into the open world, interacting with humans and operating in unstructured environments, this kind of principled combination will become increasingly essential. Safety and performance, learning and guarantees — FAOC suggests these are not in tension. They can be achieved together.

The code is open source, available on GitHub. Anyone who wants to build on this framework — to extend it, apply it, or simply understand how it works — can do so. The researchers have done the mathematical work, validated it in simulation, and made the implementation available for others to use and improve.

In the meantime, somewhere in a simulated environment, an eight-jointed arm is learning to play ping-pong. And every time it swings, it does so within its limits. It learns where to aim, not how to avoid destroying itself. The mapping handles the safety; the learning handles the strategy. Two approaches, working together, achieving what neither could alone.

That is not just a result for robotics. It is a result for anyone who believes that the best systems are those that combine the flexibility of learning with the rigor of mathematics — that make no tradeoffs between intelligence and safety.

The robot is getting better every day.