Our model is deterministic, not probabilistic. That's a deliberate choice.

One of the first questions we get in technical conversations is: "Is this a machine learning model?"

It's a reasonable assumption. In 2026, if someone tells you their software improves robot performance using a calibrated model, the default mental model is a neural network trained on data. The entire industry has been conditioned to assume that "model" means "learned from data in a way that's hard to explain."

Our model is not that. It's a physics-based, deterministic simulation of the robot. And the distinction matters more than you might think.

What the model actually is

When we calibrate a robot, we're building a mathematical replica of how that specific machine responds to commanded inputs. Not a statistical approximation. Not a learned mapping from inputs to outputs. A physics model.

A frequency response plot from a real calibration. The peaks show where the robot's structure amplifies motion — exactly what the physics model captures and compensates for.

The model captures the robot's frequency response characteristics — how the physical system amplifies, attenuates, and delays motion commands across the frequency spectrum. Every robot arm is a mechanical system with mass, stiffness, damping, friction, and compliance at every joint and link. Those physical properties determine how the structure responds when you command a motion. Our calibration process measures those responses and builds a model that reproduces them.

Given a tool path, the model predicts exactly how the robot will behave — where it will overshoot, where it will vibrate, where it will lag. Then we use optimization to modify the input command so that the robot's actual behavior matches the intended path. The controller doesn't learn a general mapping from experience. It predicts the specific physical response and compensates for it.

The output is deterministic. Same input, same model, same output. Every time.

Why not machine learning

We considered it. In the early days, we explored learned models. The appeal is obvious — let the data speak, don't impose assumptions about the physics, let a neural network figure out the relationship between commanded trajectories and actual behavior.

Here's what we found.

ML models learn correlations from training data. Physics models encode the system that generates the data.

Learned models are robust to what they've seen. A neural network trained on a set of trajectories performs well on similar trajectories. Move outside the training distribution — a new speed profile, a new payload, a different region of the workspace — and the predictions degrade in ways that are difficult to predict in advance. You don't know the boundary of what the model knows until you cross it.

Physics models generalize by construction. If the model correctly captures the mass, stiffness, and damping of the system, it predicts behavior for any trajectory, any speed, any payload within the system's physical limits. The model doesn't need to have seen a specific motion before. It understands the system that produces the motion.

Determinism is not optional for control. When you're modifying the commands that a robot's actuators receive, you need to know exactly what the controller will do. Not approximately. Not with a confidence interval. Exactly.

A probabilistic model has an inherent uncertainty band. For planning, for analysis, for decision support, that uncertainty band is manageable. For real-time control — where the output of the model directly determines the forces applied to a mechanical system — uncertainty means risk. A controller that occasionally produces unexpected outputs is a controller that occasionally moves the robot in ways you didn't intend.

We can't ship that. Our customers operate in environments where unexpected robot behavior has real consequences.

Explainability matters for adoption. When an engineer evaluates our software, they want to understand what it does. Not conceptually — specifically. What does the model capture? Why did it produce this output? If the result is wrong, where is the error?

A physics model answers those questions directly. The model has parameters — masses, stiffnesses, damping ratios, friction coefficients — that correspond to physical properties of the real machine. If the model's prediction doesn't match reality, you can identify which parameter is wrong and why. The debugging process follows the same engineering reasoning that roboticists already use.

A learned model doesn't offer that. The weights of a neural network don't correspond to physical quantities. When a learned model fails, the diagnostic is "retrain with more data" or "the input was outside the training distribution." That's not a diagnosis. It's a restart.

What we gain from physics

The physics-based approach has constraints. It requires a structured calibration process. It requires that we know enough about the physical system to write down the relevant equations. It doesn't handle phenomena we haven't modeled.

But it gives us three things that matter enormously in production:

Predictable behavior at boundaries. Our customers push robots to the edges of their performance envelopes — higher speeds, heavier payloads, longer duty cycles. Physics models degrade gracefully at boundaries because the equations remain valid even as the system approaches its limits. The predictions become less accurate as unmolded effects grow, but they don't suddenly produce nonsensical outputs. They fail in ways that make physical sense.

Per-robot specificity without per-robot training data sets. Every robot we calibrate gets a model tuned to its specific physical parameters. But the calibration process is structured and efficient — typically 5 to 10 minutes for kinematic calibration, 5 to 10 minutes for the feed-forward controller. We don't need hours of trajectory data covering the robot's full workspace. We need a targeted measurement of the system's physical properties.

Transferability across robots of the same SKU. This is a question we get frequently: if you calibrate one robot, does it work on identical robots? With a physics model, the answer is nuanced but useful. Robots of the same SKU share the same basic structure, so a model calibrated on one unit captures roughly 90% of the performance on siblings. The last 10% is per-unit variation — manufacturing tolerances, installation differences, wear. Per-robot calibration closes that gap, but even without it, the physics model provides a strong starting point because it's modeling the right system.

A learned model doesn't transfer as cleanly, because the learned weights encode not just the physics but also the specific noise and artifacts of the training data. A model trained on unit A doesn't generalize to unit B the way a physics model parameterized from unit A does.

The AI distinction that matters

We use the word "model" deliberately. In our context, it means a mathematical representation of a physical system — the same way an aerospace engineer builds a flight dynamics model or a structural engineer builds a finite element model. It predicts behavior from first principles and physical measurements.

We don't have anything against machine learning. We use data-driven techniques in parts of our pipeline where they're appropriate — certain aspects of system identification benefit from optimization methods that could loosely be called "learning." But the core model that drives the controller is physics. It's deterministic. It's explainable. And it produces the same output every time you give it the same input.

When a customer asks "is this AI?", the honest answer is no. And we think that's a better answer for what we're trying to do.

The robots we're improving operate in production environments where predictability, repeatability, and explainability aren't nice-to-have features. They're requirements. A physics model meets those requirements by construction. That's why we chose this path, and it's why we're staying on it.

Same input, same model, same output. Every time.

Reforge Robotics builds open-source motion control software that helps robots move faster, track more accurately, and behave more predictably.

Gear backlash is one of the largest sources of dimensional error in robotic milling. Here's what it does to your parts and how software-based compensation addresses it.

Robotic milling is gaining ground as an alternative to 5-axis CNC for large, complex, and low-volume parts. A KUKA KR 500, Fanuc M-900, or ABB IRB 6700 costs a fraction of a comparable gantry mill, offers a larger work envelope, and can be repurposed across part families. But accuracy remains the constraint that keeps many machining operations from making the switch.

One of the biggest contributors to that accuracy gap is backlash — and it shows up exactly where milling demands the most from the robot: at direction changes.

What is backlash?

Backlash is the small amount of free movement between mating mechanical components — particularly gears — when the direction of motion reverses. Every gear-driven joint in a robot arm has some backlash. It's a function of manufacturing tolerances, gear geometry, wear, and assembly.

The mechanism is straightforward. When a motor drives a joint in one direction, the gear teeth are in contact on one side. When the motor reverses, it must cross the backlash gap — the clearance between teeth — before the gear teeth engage on the opposite side and the joint begins moving again. During that crossing, the motor moves but the joint does not. The encoder reads a position change that hasn't happened at the link.

For a typical industrial robot, backlash per joint ranges from 0.05° to 0.3°. That sounds small, but it compounds. A 0.1° backlash error at a single joint propagates through the kinematic chain. At the end of a 2-meter arm, it becomes 3 mm or more of TCP positioning error.

Encoder readings and tracking error during repeated reversals in the Reforge validation test.

Why milling exposes backlash more than other applications

Pick-and-place, welding, and palletizing applications often mask backlash because the robot moves in long, sweeping arcs with few reversals. The joints move predominantly in one direction for each segment of the path.

Milling is different. A robot following a contour — profiling a turbine blade root, machining an aircraft skin panel, or cutting a composite layup — reverses joint directions constantly. Every concave-to-convex transition, every pocket corner, every change in contour curvature forces one or more joints through a reversal. Each reversal triggers the backlash gap.

The result is visible on the part:

• Witness marks at direction changes — small steps or ridges where the tool path shifts by the backlash error as joints reverse

• Dimensional errors on contoured surfaces — the TCP tracks inside or outside the programmed path depending on the direction of approach

• Surface finish degradation at corners and transitions — the tool dwells or skips as joints cross their backlash gaps, producing chatter marks or uneven material removal

• Non-repeatable errors — because backlash depends on the direction of the last motion, the same programmed path can produce different results depending on how the robot arrived at each point

These errors are distinct from the robot's static accuracy specification. A robot with ±0.05 mm repeatability can still produce 1-3 mm of path error during contour milling if backlash is uncompensated.

How shops deal with backlash today

The current approaches all involve working around the problem rather than solving it:

None of these approaches address the root cause: the controller doesn't know the backlash exists and can't compensate for it in real time.

How software-based backlash compensation works

Software-based compensation operates between the trajectory planner and the robot's native servo controller. It tracks the direction of motion at each joint and applies a correction when a reversal is detected.

The process has two parts:

Calibration. The system drives each joint through a structured sequence of reversals and measures the actual deadband — the angular gap where the motor moves but the link does not. This is done once per robot and captures the specific backlash characteristics of that arm, including any asymmetry between joints and any configuration-dependent variation.

Real-time compensation. During operation, the software monitors the commanded trajectory for direction reversals at each joint. When a reversal is detected, it injects a correction equal to the identified deadband, so the motor crosses the backlash gap before the joint is expected to begin moving in the new direction. The joint starts its new motion already in contact — eliminating the lag.

This layer works alongside existing accuracy improvements. Kinematic calibration corrects the robot's geometric model. Dynamic joint tracking compensates for compliance and lag. Backlash compensation handles the direction-reversal error that neither of those can address. Together, they reduce the total path error to a level that starts approaching what many milling operations require.

Measured results

We validated backlash compensation on a trajectory specifically designed to force repeated joint reversals — the kind of multi-axis coordinated motion that robotic milling demands. The robot was commanded to track a circle with the flange center while holding the TCP fixed in Cartesian space, requiring all six joints to reverse direction continuously.

The validation setup: the metal tip marks the TCP, and the labeled flange follows the commanded circle.

Estimated TCP position in the validation test. Black is software off, red is Joint Tracker plus Backlash Compensation on, and blue marks the fixed reference. These measurements evaluate the combined software effect, not backlash compensation alone.

The per-joint results show that the compensation is effective across all joints, not just the ones with the largest backlash:

A 4.70× reduction in TCP tracking error during direction reversals changes what robotic milling can achieve. For a cell that was producing ±2 mm contour error, that drops to under ±0.5 mm — moving from rough machining territory into semi-finishing range without changing the robot, the spindle, or the CAM program.

What this means for your milling operation

Backlash compensation doesn't turn a robot arm into a 5-axis CNC. The robot still has structural compliance, thermal drift, and dynamic limitations that a purpose-built machine tool doesn't. But it removes one of the largest discrete error sources in robotic machining — and it does it through software, without mechanical modification.

For operations running KUKA, Fanuc, ABB, or other industrial platforms for milling, this means:

• Tighter achievable tolerances on contoured surfaces and pocketed features — without slowing down

• Reduced manual finishing after the robot pass — fewer witness marks, more consistent surface quality

• Expanded part envelope — parts that previously required a CNC due to tolerance requirements may become viable on the robot cell

• No hardware changes — deploys through the robot's existing command interface as a software layer

The economics are straightforward. If backlash is costing you a finishing pass, a manual correction step, or a reject rate on contoured parts, software compensation addresses the root cause at a fraction of the cost of upgrading the robot.

FAQ

Can software really fix a mechanical problem like backlash?
Software doesn't eliminate the physical gear clearance. It compensates for it by anticipating direction reversals and injecting corrective motion before the joint crosses the deadband. The gear teeth still have clearance — but the joint is already positioned to the correct side of the gap when the new motion begins.

Does backlash compensation work at high feed rates?
Yes. The compensation operates at the servo loop level, so it applies regardless of feed rate. In fact, higher speeds tend to benefit more because the dynamic effects of crossing the backlash gap — including the momentary loss of contact and the impact on re-engagement — are more pronounced at speed.

Which industrial robots have the worst backlash?
Backlash is present in every gear-driven robot. Robots with cycloidal or harmonic drive reducers (common in cobots and smaller industrial arms) tend to have less backlash than those with planetary gearboxes. However, even low-backlash drives accumulate wear over time. The actual backlash of a specific robot depends on its age, usage history, and maintenance. That's why per-robot calibration matters more than platform-level specifications.

How does this compare to buying a higher-precision robot?
A precision-grade industrial arm (e.g., KUKA KR Fortec Precision or Fanuc M-20iD/25 series) reduces backlash through tighter mechanical tolerances. The trade-off is cost — typically 2-4× the base model — and the backlash still increases with wear. Software compensation can be deployed on any arm and recalibrated as conditions change, at a fraction of the hardware upgrade cost.

Reforge Robotics builds control software that makes industrial robots more accurate. Backlash compensation is part of the Covalent Joint Tracker product. Book a demo to see it on your platform.

What happens during a KineCal calibration — and why it takes minutes instead of days.

Kinematic calibration has historically been a specialist operation. A laser tracker, a trained metrology engineer, hours of setup, and a production line taken offline. The result is sub-millimeter accuracy that lasts until the robot drifts — and then you do it again.

We built KineCal to deliver comparable results in roughly 10 minutes, using the robot's own sensors and a calibration fixture that costs under $35. This post walks through what happens during those 10 minutes, how the system identification works, and what the measured results look like.

The problem KineCal solves

Every robot arm ships with a kinematic model — the mathematical description of its geometry that the controller uses to convert between joint angles and Cartesian positions. Link lengths, joint axis orientations, offsets, frame alignments.

The model is based on nominal design parameters. The physical machine is not nominal. Manufacturing tolerances, assembly variation, installation effects, and wear all create discrepancies between the model and the real geometry. The controller doesn't know the difference. It plans motions using an idealized machine, and the real machine deviates.

The result is positional error — typically 0.6 to 1.0mm on a standard 6-axis arm out of the box. That's the gap between where the controller thinks the TCP is and where it actually is.

KineCal identifies the real kinematic parameters from measured data and replaces the nominal model with one that matches the specific robot as installed.

What happens in 10 minutes

The calibration process has three steps. The first two run sequentially on the robot. The third runs in the cloud.

Step 1: Fixture setup (~2 minutes). The operator places a calibration fixture in the robot's workspace. The fixture is built from commodity hardware — an off-the-shelf bracket and reference features that can be assembled in under five minutes the first time, and under two minutes after that. No precision alignment is required. The system identifies the fixture's location from the measurement data, so approximate placement is sufficient.

The fixture provides known geometric constraints that the calibration algorithm uses to separate the robot's kinematic parameters from the fixture's position. In practice, this means the operator doesn't need to know the fixture's exact location — only that it's rigidly placed within reach.

Step 2: Automated measurement routine (~5 minutes). The operator runs a single command through the Reforge SDK. The robot executes a structured sequence of movements, approaching the calibration fixture from multiple configurations. At each configuration, the robot's joint encoders record the joint angles while the TCP contacts or approaches the fixture's reference features.

The measurement routine is designed to maximize observability of the kinematic parameters. It exercises the robot through configurations that expose each parameter's effect on TCP position — varying joint angles, approach directions, and arm configurations to decorrelate the parameters during identification.

The routine is fully automated. The operator starts it and waits. No manual teaching, no jogging, no point-by-point recording.

Step 3: Model identification (~3 minutes, cloud). The measurement data is uploaded to the Reforge API. The server runs a system identification algorithm that fits a kinematic model to the observed data.

The algorithm solves for the actual DH parameters — link lengths, joint offsets, twist angles, and link offsets — that best explain the measured joint configurations given the geometric constraints of the fixture. This is an optimization problem: find the kinematic parameters that minimize the residual error between the model's predicted TCP positions and the observed measurements.

The output is a calibrated kinematic model specific to that robot. It downloads and deploys as a software update through the SDK.

What the results look like

We've validated KineCal internally across multiple robot platforms. The consistent result is a 3x to 5x improvement in positional accuracy.

Before calibration: Typical TCP positional error of 0.6 to 1.0mm. This is the error from the nominal kinematic model — the gap between designed geometry and actual geometry.

After calibration: TCP positional error of 0.18 to 0.21mm. This is close to the repeatability limit of the robots we've tested — meaning the calibrated model has eliminated effectively all of the systematic kinematic error, and the remaining error is dominated by the robot's own mechanical precision.

The improvement ratio depends on how far the specific robot's geometry has drifted from nominal. A brand-new robot with tight manufacturing tolerances might start at 0.5mm and reach 0.18mm — roughly a 3x improvement. A robot with accumulated wear, a replaced joint, or a significant installation offset might start at 1.5mm and reach 0.20mm — closer to 7x.

The calibrated accuracy is consistent across the workspace. Unlike touch-up programming, which corrects individual waypoints, kinematic calibration corrects the underlying model. Every position the robot moves to benefits from the correction, not just the positions that were explicitly taught.

How calibration times compare across products

KineCal is one of three calibration products in the Reforge platform. The calibration time varies by product because each captures different properties of the robot:

• Kinematic Calibration (KineCal): Static geometry — link lengths, joint offsets, frame alignments. Calibration time: ~10 minutes.

• Joint Tracker: Per-joint dynamic response — lag, resonance, damping. Calibration time: ~5-10 minutes.

• Vibration Compensation (Shaper): Full structural frequency response — how the robot amplifies and dampens motion across its frequency spectrum. Calibration time: up to 48 hours of data collection.

The vibration compensation number deserves context. The 48 hours of data collection can be spread across overnight runs over the course of a week. The robot collects calibration data during periods when it would otherwise be idle. It doesn't require dedicated downtime — the calibration runs alongside or in between production shifts.

The kinematic calibration and Joint Tracker calibrations are the fast ones. Both are designed to run during a scheduled maintenance window or as part of initial commissioning. Combined, they take under 20 minutes and deliver both the geometric correction (KineCal) and the dynamic feedforward compensation (Joint Tracker).

No laser tracker required

Traditional kinematic calibration depends on external metrology — typically a laser tracker system costing $50,000 to $150,000, plus a trained operator. The laser tracker provides ground-truth TCP measurements that the calibration algorithm uses to identify the kinematic parameters.

KineCal replaces the external measurement system with a structured fixture and the robot's own sensors. The geometric constraints of the fixture provide the equivalent of ground-truth reference — not by measuring the TCP's absolute position in space, but by providing known geometric relationships that the optimization algorithm uses to solve for the kinematic parameters.

The trade-off is straightforward. A laser tracker gives you absolute accuracy referenced to a calibrated metrology instrument. KineCal gives you accuracy referenced to the geometric constraints of a commodity fixture. For applications that require traceable metrology — aerospace machining, medical device manufacturing — the laser tracker is the right tool.

For everything else — and that's the majority of robotic applications — KineCal delivers comparable results at a fraction of the cost, time, and expertise. A $35 fixture, 10 minutes of robot time, and no metrology specialist.

When to calibrate

The question of when to calibrate comes up in every evaluation. The practical answer: calibrate at commissioning, and recalibrate on a schedule matched to your accuracy requirements.

For most applications, every six months is a reasonable starting cadence. Robots in heavy use, high-precision applications, or environments with significant thermal cycling benefit from more frequent calibration — monthly or even after every tool change.

The key enabler is that 10-minute calibration time. When calibration is fast enough to fit into a maintenance window, it stops being a special event and becomes a routine step. The economics of calibration change fundamentally when the process takes minutes instead of days.

Reforge Robotics builds open-source motion control software that makes robot calibration fast, affordable, and repeatable.