Pulling Strings Without Perfect Physics: SILO Keeps the Simulator on the Factory Floor

TL;DR for operators

SILO is a robotic cable-routing system built around a useful act of engineering restraint: it does not ask one model to grasp the cable, navigate the workspace, understand every deformation, avoid every collision, and execute directly on the physical controller. Instead, it divides the job among motion primitives, a localized reinforcement-learning policy, a compact perception system, and a simulator that remains active during deployment.¹

The result is a system that:

• trains without human demonstrations;
• uses a deliberately approximate rigid-body cable model to generate large volumes of experience;
• gives reinforcement learning only the deformation-sensitive routing maneuver;
• observes local cable curvature rather than reconstructing every millimeter perfectly;
• executes policy actions inside a digital twin before sending the simulated joint outcome to the real robot.

On the authors’ physical benchmark, SILO completed one-, two-, and three-harness routing in 24/24, 22/24, and 18/24 trials. A prior hierarchical imitation-learning system reported 19/24, 14/24, and 12/24, although the paper correctly warns that this is not a strictly controlled apples-to-apples comparison. SILO’s reported three-harness cycle time was 87.48 seconds, versus an estimated 200 seconds for that earlier system.

The business message is not “reinforcement learning has solved cable assembly.” It has not. The more defensible message is that structured manufacturers may be able to trade demonstration collection and repeated controller calibration for a reusable simulation-and-deployment stack—provided the task is quasi-static, fixture geometry is known, and perception can reliably recover the relevant local deformation.

The simulator is not a crystal ball. It is closer to a very disciplined middle manager: imperfect, constantly present, and surprisingly useful when given a narrowly defined responsibility.

Cable routing is easy until the cable notices

Rigid automation works because the object usually behaves as specified. A metal component has a stable shape. A fixture remains where the CAD model says it is. A planned trajectory can be tested, refined, and replayed.

A cable is less cooperative.

Its shape changes with gravity, accumulated slack, contact, stiffness, plasticity, and the path taken moments earlier. Two apparently similar starting configurations can produce different local curves near a clip. A small entry-angle error can turn a clean insertion into a snag. The robot cannot simply memorize a geometric path because the cable keeps revising the geometry.

This is why many deformable-object systems become expensive engineering projects. Planning pipelines need carefully designed state estimators, recovery routines, collision logic, and task-specific reshaping actions. Imitation-learning systems can absorb some of that complexity, but then someone must supply enough successful demonstrations across relevant objects, poses, and failure conditions.

SILO attacks the problem differently. It accepts that cable physics will not be modeled perfectly, then designs the rest of the system so perfection is unnecessary.

That distinction matters. A casual reading might conclude that the authors succeeded because their simulator faithfully reproduces real cable mechanics. The paper says almost the opposite. Its simulated cable is a chain of rigid capsules joined by revolute joints, with simple mechanisms added to approximate elastic and plastic behavior. The model is physically useful, not physically sacred.

The architecture works because several imperfect components cover one another’s weaknesses.

None of these parts is independently revolutionary. The contribution is the way they are combined.

SILO transfers simulated outcomes, not raw policy commands

The most important mechanism appears during deployment.

In a conventional sim-to-real pipeline, a policy is trained against a simulated controller. At deployment, the same action is interpreted by the real robot’s controller. Even when both controllers nominally accept the same command, they may not produce the same motion.

The mismatch does not require a spectacular modeling failure. Small discrepancies are enough. The physics solver may not reach a target within one simulation step. Simulated proportional-derivative gains may only approximate the physical controller. Numerical residuals accumulate. The policy, meanwhile, has learned to exploit the exact motion dynamics it encountered during training.

A command that means “move approximately this much” in simulation may mean something slightly different on the robot. Repeated over a contact-rich maneuver, “slightly different” eventually becomes “missed the clip.”

SILO changes what crosses the simulation-to-reality boundary.

At each deployment step, the system:

1. reads the real robot’s joint positions;
2. synchronizes the simulated robot to them;
3. estimates local cable points from the physical scene;
4. constructs the policy observation;
5. asks the policy for an action;
6. applies that action inside the simulator;
7. obtains the joint configuration produced by the simulated controller and solver;
8. sends that resulting joint configuration to the real robot as a target.

The policy’s raw action is therefore not handed directly to the physical controller. The simulator first interprets it under the same mechanics used during training. What transfers is the simulated outcome.

This is a subtle but commercially relevant reframing. Instead of calibrating the training environment until its controller behaves almost exactly like the production controller, SILO preserves the training controller as an active runtime translation layer.

The paper’s tuned-controller baseline illustrates why that matters. The authors manually aligned the simulated controller with the real one and still observed an average joint error of roughly 0.5 degrees, with errors approaching one degree in some steps. The resulting policy achieved 0/20 successful trials without a contact penalty and 10/20 with one. SILO achieved 15/20 without requiring that reward term.

The relevant ablation is not merely saying, “Our named method performs better.” It tests the paper’s main causal claim: reusing simulated controller dynamics at runtime can be more effective than trying to identify and reproduce the physical controller closely enough in advance.

SILO also moves part of safety out of the reward function

Because the policy action is first executed in a digital twin containing the robot and harness geometry, the simulator constrains the resulting joint motion around modeled obstacles. In the paper’s illustrative comparison, omitting the harness from the digital twin permits a collision, while including it prevents the same policy from producing the penetrating motion.

This does not make SILO a general safety system. It can only constrain interactions represented accurately in the digital twin. Unknown objects, calibration errors, perception failures, cable forces, and physical-controller limits still exist outside the model.

But it does demonstrate a useful design principle: when a constraint can be enforced structurally at deployment, do not rely exclusively on a learned policy to remember a penalty it encountered during training.

Reward engineering is already enough of a scavenger hunt without asking it to impersonate a safety case.

Approximate simulation wins by covering states, not reproducing materials

The cable simulator is intentionally economical.

Each cable is represented as a sequence of rigid capsule-shaped links. Adjacent links are connected with three revolute joints, allowing bending in three dimensions. Joint drives pull the links toward stored rest positions to approximate elasticity. Those rest positions gradually shift toward the current shape to approximate plastic deformation.

The parameters do not map neatly onto standard physical material properties. The authors do not claim to have identified the exact stiffness or plasticity of each real cable. They tune the approximation to generate a useful range of behaviors.

That makes sense once the simulator’s actual role is clear.

It is not required to predict the precise physical trajectory of a specific HDMI cable. It must expose the policy to enough variations in curvature, entry angle, slack, and contact that the policy learns reactions that remain useful outside simulation.

Throughput enables this coverage. The authors train across 1,024 parallel environments, cache 32,768 intermediate reset states, and report reaching 80 million simulation samples in about five hours on an RTX 5090 system.

Those numbers are implementation-specific rather than a universal training-cost benchmark. Still, they establish the practical trade: a simplified model allows simulation volume that would be difficult to obtain from a slower, more physically detailed deformable-body solver.

The ablation on initial-state randomization reveals what that volume is buying.

This experiment is an ablation of the training distribution, not a second headline result. Its purpose is to test whether successful transfer depends on exposing the policy to varied cable entry angles and intermediate shapes.

It does.

A policy trained around a narrow reset distribution can perform inside that neighborhood and still fail when the physical cable approaches the harness from a more difficult angle. Expanding the distribution raises success substantially, though the most extreme configurations remain difficult.

This is the deeper correction to the high-fidelity misconception. The system does not close the reality gap by making one simulated cable look exactly real. It reduces dependence on exact matching by training across enough plausible local states and injecting observation noise.

In other words, the simulator is useful because it is prolific and directionally correct. Robotics, occasionally, permits pragmatism.

Reinforcement learning is used only where the cable fights back

The full task is long-horizon:

• find and grasp a cable end;
• move toward a harness;
• route through it;
• travel to the next harness;
• repeat without losing the cable or accumulating an unrecoverable deformation.

Training one policy end to end would force reinforcement learning to discover obvious free-space motions while simultaneously solving contact-rich cable insertion. The easy phases would lengthen episodes and dilute the learning signal from the difficult phase.

SILO instead localizes reinforcement learning to routing through a single harness.

Classical motion primitives perform two structured operations:

• GraspCable approaches the cable endpoint and secures it.
• MoveToHarness moves the gripper to a predefined pose behind the next harness.

In simulation, these primitives generate intermediate states in which the cable has already been grasped and positioned near a harness. Training episodes begin there. During physical execution, the same task decomposition is reused across a sequence of one to three harnesses.

This hybrid structure is central to the result. It makes the learning problem shorter, permits simpler reward design, reduces simulation cost, and provides a direct route from a one-harness policy to a multi-stage system.

The approach is therefore not evidence that learned policies should replace classical robotics. It is evidence that learned policies become more useful when classical robotics removes the parts that do not need learning.

For operators, this suggests a practical scoping rule:

Apply learning to the segment where uncertainty changes the required action. Keep deterministic tooling for movement whose geometry and objective are already well specified.

That principle extends beyond cable routing. A hose-insertion system may use planning for approach and transport, then learned control for the final deformation-sensitive engagement. Textile handling could use deterministic repositioning between localized learned manipulation skills. Seal placement, tube feeding, and flexible-component assembly may admit similar decompositions.

Those are business inferences, not results demonstrated by this paper. The study evaluates cable routing on one robot platform. But the design pattern is more transferable than the specific benchmark.

Four local points are enough to represent the problem SILO actually solves

The policy does not consume raw images. It receives:

• the robot’s joint angles;
• the tool-center-point pose;
• the positions of four cable points closest to the gripper.

Obtaining those points in the physical system requires a perception pipeline. A Zed 2 stereo camera supplies images. Foundation Stereo estimates depth. SAM2 segments the cable. The segmented depth is converted into a three-dimensional point cloud, cleaned, ordered along its principal direction, and resampled into an equal-length polyline compatible with the simulated cable representation.

The full cable is not reconstructed with high precision. It does not need to be.

Only the four closest points are passed to the policy. These points encode local curvature immediately behind the gripper—the information needed to decide whether to angle, swing, or continue through the harness.

The observation-space ablation is especially informative:

This is a sanity-check ablation. It asks whether the learned policy is genuinely reacting to deformation or simply replaying a nearly fixed movement.

One point gives position but little meaningful curvature. Performance collapses to 1/20. Two points provide a local direction and improve success to 11/20. Four points provide a richer curvature signal and reach 15/20.

Adding still more points did not keep helping. The authors report diminishing returns and greater vulnerability to occlusion. In a dense harness setup, attempting to observe more of the cable creates a wider surface for perception failure and distribution shift.

This is an elegant example of choosing the smallest state representation that preserves the decision-relevant variable. More perception is not automatically more intelligence. Sometimes it is merely more places for a camera to be wrong.

The pipeline does have limits. The polyline-fitting procedure is less reliable for large U-shaped curves, crossovers, and severely twisted configurations. It also begins with a small amount of human input: the first SAM2 frame is initialized with roughly one to three clicks for each cable, after which that annotation is reused. The experiment involved four cable types, so four initial annotations were required.

That is far from collecting thousands of demonstrations. It is also not a completely setup-free perception system.

The main results show a working system, not a universal benchmark victory

The primary real-world experiment routes a cable through one, two, or three U-shaped harnesses. Harness positions and in-plane rotations vary within predefined regions.

The system’s reported success rates are:

These are the paper’s main performance results. They support the claim that the complete SILO system can transfer from simulation and execute multi-stage cable routing with meaningful reliability.

They do not support the stronger claim that SILO has definitively defeated hierarchical imitation learning under controlled conditions.

The baseline figures come from prior work. The hardware, assumptions, implementation details, and recovery mechanisms differ. The imitation-learning system emphasizes high-level planning, reshaping, and recovery. SILO assumes known harness geometry and pose, then demonstrates reactive low-level routing. The reported 200-second baseline time is estimated from published video rather than measured inside the SILO experiment.

The authors explicitly acknowledge this mismatch. That admission should remain attached to the comparison rather than being quietly misplaced somewhere in a limitations paragraph.

The cycle-time improvement is still operationally interesting. The earlier system frequently replans and regrips to reshape the cable. SILO’s reactive policy handles difficult local curvatures directly, reducing those interruptions. Its mean end-to-end time of 87.48 seconds is less than half the estimated 200-second baseline.

But 87 seconds is not automatically an attractive industrial takt time. Whether it is fast enough depends entirely on the production process, labor alternative, quality requirements, and the degree to which multiple stations can run in parallel.

The latency breakdown shows where optimization would matter

For the three-harness task, the authors report the following average time allocation:

This table is implementation and bottleneck evidence, not proof of the central transfer claim.

It does, however, correct an easy commercial concern. Keeping a simulator active during deployment sounds computationally expensive, but simulation accounts for about 14% of total runtime. Neural-network policy inference is negligible. Robot movement and perception dominate.

That suggests three practical conclusions.

First, replacing the policy with a smaller network would accomplish very little. The policy already consumes less than a third of a second across the full run.

Second, perception acceleration could materially reduce cycle time. Depth estimation plus segmentation accounts for roughly 30 seconds in this implementation.

Third, the start-stop synchronization design places SILO firmly in quasi-static manipulation. The physical policy runs at 10 Hz, aligned with the perception pipeline. Faster hardware may reduce latency, but dynamic tasks would require architectural changes, not merely a newer GPU.

Generalization across four cables is promising, but diameter still collects its tax

The authors also test three-harness routing with four physical cable types:

The first three cables achieve identical success despite differing materials and stiffness profiles. This is a robustness test supporting zero-shot transfer across some cable variation.

The thicker HDMI cable performs worse. Its measured diameter is 8.0 mm, compared with 6.0 mm for Ethernet, 6.2 mm for the charger cable, and 7.9 mm for the nylon rope. The authors attribute the additional failures to reduced clearance when the cable and harness geometry leave less room for error.

This result is useful precisely because it is not spotless. It identifies a mechanical boundary that state randomization cannot simply wish away.

A policy may generalize across stiffness and material while still being constrained by geometry. “Cable type generalization” therefore should not be translated into “arbitrary flexible component generalization.” Clearance, friction, connector shape, surface texture, cable memory, and fixture geometry could each change the problem materially.

The experiment establishes breadth across four objects. It does not map the full design envelope.

The learned behavior is reactive rather than merely replayed

Qualitative analysis identifies two behaviors that emerged during simulation training.

The first is angling. The policy changes the gripper’s orientation while pushing the cable into the harness. In a comparison using the same translational path but fixed orientation, the learned rotation depresses the cable roughly 8 mm farther—approximately one cable diameter—and completes the insertion where the fixed-orientation version does not.

The second is swinging. When the cable curves to the right of the harness, the robot swings left; when it curves left, the robot swings right. The movement responds to the observed deformation rather than following a single predefined path.

These visualizations are exploratory qualitative evidence. They help explain what the policy may have learned, but they are not large controlled experiments.

Combined with the observation ablation, however, they support a coherent interpretation: the policy uses local curvature information to select corrective movements that were not explicitly written into the reward function or motion primitives.

This matters for business evaluation because it distinguishes two very different automation proposals.

One is a learned trajectory player that survives modest variation.

The other is a reactive controller whose action changes with the physical state.

SILO provides evidence for the latter within its tested routing setup.

What the paper directly shows, what businesses may infer, and what remains unknown

The practical meaning of robotics research is easily inflated by sliding from a laboratory result to an industry-wide conclusion without marking the transition. Here is the cleaner separation.

The strongest business pathway is therefore not immediate replacement of cable-assembly labor. It is a change in how an automation project might be engineered.

A conventional project may spend heavily on demonstrations, controller matching, deployment-specific code, collision penalties, and handcrafted recovery logic. SILO proposes shifting some of that investment into:

• an approximate but scalable training simulator;
• reusable motion primitives;
• a calibrated runtime digital twin;
• compact state estimation;
• targeted randomization around known failure modes.

That may reduce one class of cost while increasing another. A live simulator becomes part of the production dependency graph. Calibration and geometry management become operational assets. The perception pipeline needs monitoring. GPU availability and software-version consistency matter at deployment, not only during model development.

The paper argues that SILO reduces engineering overhead, and its code-reuse logic is plausible. It does not measure developer hours, maintenance burden, integration cost, or total cost of ownership. Those remain hypotheses for a production pilot to test.

A sensible pilot would test the operating envelope before chasing autonomy

A manufacturer evaluating this approach should not begin with the most variable flexible-assembly process in the plant. The architecture is best aligned with tasks having:

• fixed or CAD-defined fixtures;
• stable robot kinematics;
• quasi-static manipulation;
• repeated local deformation challenges;
• observable cable or hose geometry;
• enough product volume to justify simulation and integration;
• limited need for rapid unplanned recovery.

The pilot should measure more than average success.

Useful production-facing metrics would include:

1. success by entry angle, component type, and fixture clearance;
2. mean cycles between human interventions;
3. failure severity, not only failure frequency;
4. perception degradation under lighting, occlusion, wear, and contamination;
5. recovery time after a snag;
6. changeover effort for a new cable or fixture;
7. calibration drift across shifts;
8. total engineering hours versus scripted and demonstration-based alternatives;
9. achievable cycle time after controller and perception optimization;
10. behavior when geometry in the digital twin is wrong.

The last item is particularly important. SILO gains safety and consistency by trusting modeled geometry during action execution. That same reliance creates a failure mode when the model is stale.

A digital twin is useful only while someone remains responsible for its relationship with reality. The word “twin” has always been doing rather more reputational work than the synchronization process.

The boundaries are structural, not cosmetic

Several limitations define where SILO should and should not be expected to work.

Known harness geometry and poses

The system assumes harness shapes, locations, and routing directions are available in advance. This is reasonable for many fixture-based assembly stations. It is restrictive for cluttered, changing, or weakly structured environments.

A separate perception or high-level planning system could estimate them, but that would add another source of uncertainty not tested here.

Quasi-static execution

SILO synchronizes simulation and reality through sequential control steps. The robot moves, perception updates, the simulator is synchronized, and another target is produced.

This works for cable routing because relevant dynamics evolve slowly enough between commands. It is poorly suited to throwing, whipping, rapid insertion, or tasks in which unmodeled motion continues significantly between synchronization points.

Limited physical scope

The main setup uses one Franka Research 3 robot, one U-shaped harness design, one camera arrangement, four cables, and up to three harnesses. Each reported real-world condition uses 20 or 24 trials.

The evidence is meaningful for a robotics paper. It is not a reliability qualification for manufacturing.

Perception remains a dependency

The state estimator handles moderate occlusion but struggles with large U shapes, crossovers, and more twisted geometries. The paper’s best policy also fails primarily when the cable snags and needs finer adjustment than the policy supplies.

The system does not include a general recovery planner. A failed insertion can still require intervention or a higher-level strategy.

Collision avoidance depends on modeled reality

SILO prevents certain penetrations because the modeled harness constrains simulated motion. This is not equivalent to proving physical safety. Geometry errors, calibration drift, unmodeled objects, unexpected forces, and controller behavior remain outside that guarantee.

These are not ceremonial cautions added to make a promising result sound responsible. They determine the target market.

SILO is not a general deformable-object robot brain. It is an architecture for structured, quasi-static manipulation in which the environment can be represented accurately enough for a runtime simulator to remain useful.

That is narrower than “general robotics.” It is also much closer to something an engineering team could actually evaluate.

The real contribution is disciplined mismatch management

SILO does not eliminate the sim-to-real gap. It separates the gap into manageable pieces.

The cable simulator is allowed to be approximate because training emphasizes state coverage and the deployed policy observes the real cable. The controller mismatch is reduced by executing actions through the same simulator used during training. Collision handling moves partly into modeled geometry. Classical motion primitives remove predictable phases from the learning problem. A compact observation focuses perception on local curvature rather than total scene reconstruction.

The system succeeds not because every model is accurate, but because each model is asked to be accurate about a smaller thing.

That is the broader lesson.

Robotics teams often frame deployment as a final migration: train in simulation, remove simulation, and hope the policy has absorbed enough reality to survive alone. SILO treats the simulator less like a temporary classroom and more like a production component.

For structured cable routing, that choice produces a credible result: higher reported success, substantially shorter reported cycle time, transfer across several cables, and less dependence on controller tuning or demonstration collection.

Whether it becomes economically compelling will depend on production-scale reliability, integration cost, changeover effort, and the value of the labor or downtime it replaces. Those questions are not answered by 24 trials, nor should anyone pretend otherwise.

But the paper identifies a technically coherent path toward answering them.

Perfect physics can remain in the brochure. The factory may only need a simulator that is fast, synchronized, and given exactly the right job.

Cognaptus: Automate the Present, Incubate the Future.