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.

When a model trained on one machine can cover the fleet — and when it can't.

One of the first questions we hear from teams evaluating Reforge is about scaling: if I calibrate one robot, do I need to calibrate every other robot of the same model?

The short answer is no — with a caveat that matters. A model trained on one unit of a given SKU will transfer to other units of the same SKU and deliver roughly 90% of the calibrated performance. The remaining 10% is the gap between nominally identical and physically identical. Whether that gap matters depends on your application.

This post explains what transfers across robots, what doesn't, and how to decide the right calibration strategy for your fleet.

What the model actually captures

When we calibrate a robot, we're building a mathematical model of how that specific machine behaves. For kinematic calibration, the model captures the real geometry — actual link lengths, joint axis orientations, offsets, and frame alignments as measured on the physical hardware. For dynamic calibration (vibration compensation and feedforward control), the model captures frequency response characteristics — how the robot amplifies or dampens motion at different frequencies, with what lag, and with what coupling between joints.

These properties come from two sources: the design of the robot and the specific physical instance.

Design-level properties are shared across all units of a SKU. The nominal link lengths, the gear ratios, the actuator types, the structural topology — these are determined by the engineering drawings and are consistent across the production run. A model captures these faithfully, and they transfer perfectly.

Instance-level properties vary from unit to unit. Manufacturing tolerances in link dimensions, joint axis alignment, gearbox backlash, bearing preload, cable routing, and assembly torques. These are small variations — typically tenths of a millimeter in geometry and single-digit percentage differences in dynamic parameters — but they compound through the kinematic chain and produce measurably different behavior at the TCP.

The 90% transfer

When you apply a model trained on Robot A to Robot B of the same SKU, you get the design-level correction for free. The systematic errors that all units of that model share — the difference between the nominal kinematic parameters and the actual average for that production run — are captured and corrected.

That correction alone is significant. On the platforms we've validated, the design-level error accounts for the majority of the total kinematic error. Correcting it brings most units from roughly 0.6-1.0mm of positional error down to the 0.2-0.3mm range.

The remaining instance-level error — the per-unit variation from manufacturing tolerances — is what the transferred model doesn't capture. It's real, but it's small relative to the uncalibrated baseline. This is what we mean by 90% of the performance: the transferred model eliminates most of the error, but the last increment of accuracy requires per-unit calibration.

When 90% is enough

For many applications, a transferred model is the right answer.

If your tolerance budget is 1mm and the uncalibrated robot has 2-3mm of error, a transferred model that brings every unit down to 0.2-0.3mm gives you substantial margin. You don't need per-unit calibration. You need one calibration per SKU, and every robot benefits.

This is the scaling story that matters for fleet operators. Calibrate one unit. Deploy the model across all units of that SKU. The marginal cost of adding the next robot is zero calibration time.

Applications where this works well:

• Pick-and-place with tolerances above 0.5mm. The transferred model puts every unit well inside the budget.

• Palletizing and machine tending. These applications are tolerance-friendly and benefit primarily from the speed improvement that vibration compensation provides. The dynamic model transfers well across units because the structural design is shared.

• Visual inspection at fixed stations. If the robot moves to inspection positions and stops, the accuracy requirement is at the waypoints only. A transferred kinematic model is usually sufficient.

When you need per-unit calibration

The 10% gap matters when your application consumes the full accuracy budget.

If your tolerance is 0.3mm and the transferred model delivers 0.2-0.3mm, you're operating at the margin. Some units will pass. Others won't. The variation between units becomes the limiting factor.

Per-unit calibration closes the gap. Calibrating the specific robot identifies its actual geometry — not the average geometry of its SKU — and produces a model that reaches the platform's accuracy floor. On our validated platforms, that floor is approximately 0.18-0.21mm.

Applications where per-unit calibration matters:

• Precision assembly and insertion tasks. Connector insertion, pin alignment, and similar operations where the tolerance is smaller than the per-unit variation.

• Offline programming without touch-up. If the goal is to generate paths in simulation and run them on the real robot without manual correction, per-unit accuracy is the requirement. The transferred model gets close. Per-unit calibration eliminates the remaining teaching step.

• Multi-robot coordination. When two or more robots need to agree on the location of a shared workspace, their individual kinematic errors need to be independently corrected. A shared model doesn't resolve the relative error between units.

• Quality-critical applications where out-of-tolerance means scrap — welding, dispensing, laser processing — and the cost of a single bad part exceeds the cost of calibrating the robot.

The practical approach

The calibration strategy that makes sense for most fleets is a two-tier approach.

Tier 1: One model per SKU. Calibrate one robot of each model in your fleet. Deploy that model across all units of the same SKU. This covers the design-level error and handles the majority of the accuracy improvement with minimal effort.

Tier 2: Per-unit calibration where needed. For robots in precision applications, or for units that show higher-than-expected error with the transferred model, run per-unit calibration. The process takes roughly 10 minutes for kinematic calibration. It can be integrated into commissioning workflows or run during scheduled maintenance.The process for other products is similar because our system fine-tunes the base model, combining the initial data with a smaller dataset.

The key advantage of this approach is that per-unit calibration is not expensive. With Reforge's KineCal, the calibration fixture costs under $35 in commodity hardware. The measurement routine is automated through the SDK. The model fitting runs in the cloud. An operator can calibrate a robot without metrology expertise or specialized equipment.

When calibration takes 10 minutes and costs effectively nothing in equipment, the question shifts from "can we afford to calibrate every robot?" to "is there a reason not to?"

Recalibration and drift

The transferability question also has a time dimension. A model trained today captures the robot's current state. Over months, mechanical wear changes the properties — gearbox backlash increases, bearings develop play, structural characteristics shift.

We recommend recalibrating at a minimum every six months. Robots in heavy-use or high-precision applications benefit from more frequent calibration — even as often as monthly. The calibration process is designed to run during scheduled downtime or overnight without taking the robot offline during production.

A continuous monitoring feature is on our roadmap that would use ongoing data collection to detect drift and trigger recalibration automatically. Until then, scheduled recalibration at a cadence matched to your application's tolerance budget is the practical approach.

The bottom line

You don't need to calibrate every robot from day one. A model trained on one unit covers the fleet at roughly 90% of the calibrated performance. For most applications, that's more than sufficient.

Where the last 10% matters — precision assembly, offline programming, multi-robot coordination — per-unit calibration/fine-tuning closes the gap in about 10 minutes with no specialized equipment.

The practical strategy: calibrate one per SKU as the baseline, then per-unit where the application demands it. Scale the fleet first. Calibrate precisely where it counts.

—

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

It depends on the robot. Here's how to think about it.

The most common question we hear in customer conversations is some version of: "What kind of results should we expect?"

It's a fair question, and it doesn't have a single answer. After deploying our control software across multiple robot platforms from different manufacturers, we've learned that the honest answer is: it depends on the robot. But not in the way most people assume.

The bell curve

There's a bell curve to how much software-based calibration and control can improve a given robot.

On one end are robots with genuinely poor mechanical engineering — excessive backlash, inconsistent manufacturing, structural problems that no amount of software will compensate for. If the hardware can't repeat a motion consistently, there's no model that can predict what it will do next. These robots see limited improvement because the problem isn't the controller or the calibration. It's the machine.

On the other end are over-engineered robots — machines built with such tight tolerances and rigid structures that they already perform close to their theoretical limits. A precision industrial arm from a top-tier manufacturer running well within its speed and load envelope doesn't leave much room for software to improve. The delta between the commanded trajectory and actual behavior is already small.

The large middle is where the results happen. This is most of the robots we see in the field. Machines with decent mechanical engineering that are underperforming because their controllers don't account for the actual dynamics of the physical system. Robots that vibrate, overshoot, or drift because the software was tuned for a generic case, not the specific machine as installed.

For that middle range — which includes most cobots, most affordable industrial arms, and most robots operating near their speed or load limits — the improvements are substantial.

Three tiers of improvement

We've built three products that each address a different layer of robot performance. The improvement you see depends on which layer is your bottleneck.

Vibration compensation

This is where we started, and it remains the most dramatic result. Vibration compensation uses a calibrated dynamic model of the robot to predict and pre-compensate for structural vibration before it happens. Instead of commanding a trajectory and waiting for the robot to stop shaking, the controller shapes the input so the robot arrives at the target position cleanly.

Across our deployments, we've consistently demonstrated over 90% reduction in residual vibration. In applications where the robot must stop and wait for vibration to settle before executing the next operation — visual inspection, precision pick-and-place, dispensing — this translates directly to throughput. We've measured 2x productivity improvement in these scenarios, because you're eliminating the settling time that was consuming half of every cycle.

The catch: vibration compensation requires the most calibration data. Currently up to 48 hours of data collection, which can be spread across overnight runs over the course of a week. We're actively working to reduce this. But it's important to be transparent — this isn't a 10-minute setup.

Kinematic calibration

Every robot ships with a kinematic model — a mathematical description of the arm's geometry. And on virtually every robot we've measured, that model doesn't match the actual machine. Manufacturing tolerances, installation effects, wear, and thermal drift all contribute to a gap between where the controller thinks the robot is and where it actually is.

Kinematic calibration identifies the robot's real geometric parameters by measuring its actual positions across its workspace. The result is a corrected model that accounts for the specific machine as installed.

The improvement: 3 to 5x increase in positional accuracy. On robots where we've measured 0.6 to 1.0mm of positional error, calibration brings that down to 0.18 to 0.21mm. And the calibration itself takes approximately 10 minutes. No laser tracker. No metrology specialist. A commodity calibration fixture that costs under $35 and assembles in under five minutes.

This is the product where we hear the most immediate "I need that" from customers, because the problem is so widespread and the current alternative — a $50,000 to $150,000 laser tracker — is prohibitively expensive for most teams.

Feed-forward controller

The feed-forward controller sits between the trajectory planner and the robot's actuators. It uses a calibrated dynamic model of each joint to predict how the robot will actually respond to a given command, then pre-compensates the trajectory so the end-effector follows the intended path more closely.

The improvement: up to 10x reduction in tracking error. On one platform, we measured TCP tracking error drop from over 10mm to under 2mm. On another, from 7.6mm to 1.9mm. The more important result is that tracking accuracy stays approximately constant as speed increases — the controller compensates for the dynamics that cause error to grow with speed on stock controllers.

For teleoperation, this changes what the system can physically do. At 5mm of tracking error, you're limited to coarse tasks. At 2mm, precision assembly, connector insertion, and close-tolerance operations become feasible.

What determines where you fall on the curve

The question isn't just "how much improvement" but "which improvement matters for your application."

If your robots are running visual inspection and losing throughput to settling time, vibration compensation is your highest-leverage product. If you're running offline-programmed paths and spending days on touch-up programming because the robot doesn't go where the model says, kinematic calibration solves that. If you're building a teleoperation system and the tracking fidelity limits what tasks the operator can perform, the feed-forward controller is what you need.

Some customers need all three. Some need one. The bell curve applies to each product independently — a robot that sees 90% vibration reduction might only see 3x accuracy improvement from kinematic calibration, or vice versa, depending on where the performance gap lives.

The one thing we can say with confidence: for robots in the middle of that bell curve — which is most of them — the improvements are not incremental. They're step-changes. And they come through software, with no hardware modifications.

How to find out where your robot sits

We've designed the calibration and evaluation process so you can find out quickly. Kinematic calibration takes about 10 minutes. The feed-forward controller calibration takes 5 to 10 minutes. Vibration compensation takes longer but can run in the background during normal operations.

If you're curious whether your robot is in the middle of the bell curve — where the improvements are real and measurable — the fastest way to find out is to run the calibration and look at the data.

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