Reinforcement Learning for CAM: Safe, Physics‑Informed Toolpath Optimization

Why bring reinforcement learning (RL) into CAM?

The problem landscape

Computer-aided manufacturing sits at the intersection of geometry, physics, and machine control, and toolpath planning is rarely a tidy optimization problem. It is, by nature, a mixed discrete–continuous, high-dimensional search under tight safety and quality constraints. Choosing a strategy like zig‑zag versus adaptive clearing is a discrete decision; tuning step‑over, step‑down, feed, spindle speed, and—on 5‑axis—the tool orientation vector are continuous controls. These choices are coupled by the evolving in‑process stock and machine dynamics, forming a nonstationary environment where early choices shape later feasibility. Objectives frequently conflict: minimizing cycle time can accelerate **tool wear**, aggressive surface finish targets can compromise dynamic **stability**, and pursuit of low energy can reduce **throughput**. Traditional rule packs and templates encode decades of experience, yet they tend to fracture when facing unfamiliar geometries, novel alloys, cutter coatings, or variances across spindles, controllers, and fixtures. What appears optimal for a 3‑axis aluminum pocket may underperform or chatter in a thin‑walled titanium rib. The combinatorial explosion of parameters grows further with feature-rich parts and multi-setup workflows, while the consequence of mistakes—collision, **gouging**, or tolerance miss—is severe. In short, conventional CAM tooling often treats programming as a one‑way, open‑loop process that leans heavily on conservative heuristics, leaving performance on the table when conditions deviate from expectations.

Consider the dynamics of in‑process material engagement. As the cutter traverses, local engagement angles and chip thickness fluctuate with topology, causing spikes in force and temperature. Without adaptive modulation, a safe global feed may be too slow in air and too fast in corners. In 5‑axis trimming or blisk finishing, maintaining a uniform scallop height while respecting axis limits and avoiding holder collisions involves intricate kinematic couplings. The planner must reason with a high‑fidelity stock model, machine limits, and surface tolerances simultaneously. That complexity is precisely where fixed rules struggle, because they cannot anticipate all context combinations. The result is a bias toward conservative settings or repeated trial‑and‑error edits on the shop floor. An approach that learns from data and adapts across contexts is attractive, provided it comes with strong guardrails and traceability.

• Mixed discrete–continuous search across strategy types and parametric settings.
• Conflicting objectives spanning cycle time, tool life, finish, stability, and energy.
• High penalty for errors due to collisions, overcut, or tolerance violations.
• Heuristic fragility when encountering new geometry, materials, or machine variability.

What RL adds

Reinforcement learning reframes CAM as an experience-driven control problem that can adapt to the specifics of your machines, tools, and materials. Instead of freezing knowledge into brittle if‑else logic, RL iteratively improves a policy by interacting with a simulator or by learning from historical data. This enables **experience‑driven optimization** that naturally embraces the mixed discrete–continuous nature of toolpath planning: a hierarchical policy can choose the operation family, instantiate path macros, and modulate continuous feeds and speeds in real time. Equally important, RL supports principled **multi‑objective trade‑offs** through constrained optimization (e.g., a Lagrangian handling of chatter risk or force limits) or dynamic scalarization where priorities shift by context—roughing prioritizes material removal rate, finishing prioritizes surface deviation and scallop height. When connected to production telemetry and a **digital twin**, policies can continue improving from real outcomes, accounting for spindle health drift, coolant changes, or subtle fixture compliance not captured in initial assumptions.

What does this look like in practice? A policy might learn to increase feed in regions where the multi‑dexel stock model predicts low engagement and reduce feed near tight radii where the **engagement angle** spikes. In 5‑axis finishing, it could bias the tool orientation to minimize deflection and ensure kinematic smoothness given your controller’s look‑ahead and jerk limits, striking a balance between surface quality and machine wear. RL can also embrace the diversity of your tool catalog, discovering when **trochoidal** patterns outperform spiral strategies in deep pockets, or when a smaller rest tool nets better cycle time due to more agile motion. The core value is adaptability: a mechanism to search the policy space guided by actual outcomes rather than static assumption, with the ability to re‑specialize as your environment evolves.

• Adaptive policies tailored to specific machines, spindles, and holders.
• Constrained RL to respect physics and quality boundaries while optimizing throughput.
• Continuous improvement by closing the loop with telemetry and digital twins.

Guardrails and practicality

While RL is powerful, any credible CAM deployment must be safety‑first. Hard constraints—collision, overcut, machine limits—are non‑negotiable and require **shields** and verifiers around the learner. A pragmatic design places robust geometry checks, kinematic feasibility filters, and **tolerance analyzers** in the action loop, projecting the agent’s proposals back onto feasible sets when necessary. Rather than discarding proven domain knowledge, hybridization is essential: physics‑based material removal and mechanistic force models constrain what the policy is allowed to attempt, and expert heuristics initialize or bound the search. This reduces data demands, accelerates training, and increases trust because the agent learns within a well‑lit corridor. The result is not a black box replacing CAM engineers, but a copilot that suggests and adapts within tightly enforced margins.

Practically, that means an RL layer that proposes parameter updates or path macro choices which are then vetted by a fast **collision/gouge** checker and a chatter proxy before being accepted. On‑machine trials begin in low‑risk regimes (e.g., parameter tuning on 2.5D roughing) with automatic rollback to deterministic baselines if uncertainty spikes. Explainability matters: policies should expose why a change was made—lower predicted scallop, higher tool load margin, or reduced air cuts—so programmers can validate rationale quickly. Finally, integration into existing CAM ecosystems as a plugin or suggestion engine preserves current workflows; it augments human judgment rather than replacing it, maintaining **traceability** and protecting production schedules.

• Runtime shields for collision, tolerance, and kinematic feasibility.
• Physics-informed policies to cut data needs and improve generalization.
• Human-in-the-loop gating and explainability to sustain trust.

Formulating RL for toolpath generation: states, actions, rewards, and algorithms

State representations

State is the lens through which the policy perceives the world. For toolpath generation, state should marry geometric intent, remaining stock, machine context, and process signals. Geometry can be described with traditional CAD entities—B‑rep features such as pockets, bosses, and fillets with **NURBS** patch metadata—or learned encodings like signed distance fields (SDF), multi‑dexel grids, octrees, or point clouds. A hybrid is often effective: parsed CAD features set goals (e.g., finish these walls to 0.8 Ra), while dense fields guide local decisions (e.g., adjust feed in corners where curvature and remaining stock will spike engagement). The in‑process stock is crucial; fast dexel/voxel occupancies and **scallop height maps** provide the policy with a live view of material left. Derived fields like engagement angle, chip thickness estimates, or a “remaining material heat map” focus attention on risk and opportunity.

Complementing geometry and stock are the machine and tool context variables: axis configuration (3/4/5‑axis), spindle power/torque envelopes, tool catalog with length/diameter, toolholder and fixture models, and estimates of **current tool wear**. These govern feasibility and risk; the same path is safe on one machine and hazardous on another. Finally, process signals—either simulated or sensed—round out the state: predicted cutting forces, chatter indicators from stability maps, temperature and deflection estimates, and motion smoothness metrics (jerk/accel). Packaging these signals compactly is nontrivial: graph encodings over toolpath segments, 3D convolutions over multi‑dexel grids, or implicit SDF encoders can all work depending on problem scale. What matters is providing a stable, informative state that captures the geometry‑physics‑machine coupling driving performance.

• Hybrid geometry encodings using both CAD features and learned fields.
• In‑process stock with dexel/voxel and scallop maps for engagement awareness.
• Machine/tool context including kinematics, power, holders, and wear.
• Process signals (force, chatter, temperature, deflection) for risk awareness.

Action spaces

Actions span both discrete choices and continuous controls. Discrete actions include operation type (roughing, finishing, rest), strategy family (zig‑zag, adaptive, spiral, **trochoidal**), tool selection, and coolant mode. Continuous controls cover step‑over, step‑down, feeds and speeds, tool tip position and orientation in 5‑axis, and even spline or arc parameters for segment generation. To manage this complexity, a **hierarchical framing** is effective: a high‑level policy selects a strategy family and rough plan; a mid‑level policy instantiates path macros or sub‑curves; a low‑level controller modulates feed/spindle based on instantaneous engagement signals to maintain force targets and avoid chatter. This mirrors how experienced programmers think—first pick the general approach, then tune the details.

Concretely, a 5‑axis surfacing agent might output a field of tool orientation vectors constrained by reachability and collision checks, while a low‑level agent performs feed override to keep force within a margin of stability. Conversely, in 2.5D pockets, the high‑level policy might choose adaptive clearing with a rest pass, the mid‑level sets arc smoothing and lead‑in styles, and the low‑level handles feed ramp‑ups during air‑cut exit. Representing these actions smoothly is important for controller compatibility; for instance, orientation vectors can be parametrized on the unit sphere to avoid singularities, while path segments can be constrained to G1/G2/G3 constructs the post‑processor supports. The outcome is an action space that aligns with both **CAM semantics** and controller realities.

• Discrete selections: operation, strategy, tool, coolant.
• Continuous parameters: step‑over/down, feed, speed, 5‑axis orientation, arc/spline controls.
• Hierarchical control: strategy → macro generation → real‑time modulation.

Reward and constraints

The reward should reflect what production cares about while keeping the agent within guardrails. Useful components include positive terms for material removal rate and negative terms for air‑cutting, plus shaping toward target **surface deviation** or scallop height. Penalties for exceeding **force/torque margins**, approaching chatter lobes, or elevated temperature help steer away from risk. Energy use, tool wear proxies (e.g., cumulative cutting length weighted by force or temperature), and smoothness penalties for excessive jerk or acceleration complete the picture. Because safety boundaries are hard constraints rather than negotiable trade‑offs, they should be enforced as shields: if a proposed action would collide, gouge, break tolerance, or violate machine envelope/axis limits, it is clipped, projected, or vetoed before execution. That ensures the reward remains a performance signal, not a damage tax.

In practice, constrained RL with a Lagrangian approach can maintain expected violations below specified budgets, while **control barrier functions** can enforce invariants like minimum standoff from fixtures. Shielded RL threads a similar needle by placing fast collision/overcut checkers inside the environment step, rejecting unsafe actions and, optionally, returning a shaped penalty so the policy learns the edges of feasibility. When the agent must make risk‑aware decisions—say, flirting with the boundary of chatter stability—distributional RL provides a richer estimate of outcome tails rather than just expectation, encouraging conservative choices when the tail‑risk is unacceptable. Together, these techniques produce agents that optimize aggressively within firm, physics‑respecting bounds.

• Reward terms: MRR, surface deviation, air‑cut penalty, force/temperature, energy, wear, smoothness.
• Hard constraints via shields: collision, gouging, tolerance, kinematic/thermal limits.
• Techniques: Lagrangian constrained RL, shielded RL, control barrier functions, distributional RL.

Algorithms and model choices

Algorithm selection depends on data availability and the control horizon. Where abundant historical CAM/G‑code and simulation logs exist, **offline RL** is a strong starting point, training policies without risky online exploration. Imitation learning further accelerates convergence by cloning expert toolpaths and then fine‑tuning for performance. For continuous low‑level control (feeds/speeds, 5‑axis orientation), off‑policy methods like SAC or TD3 are efficient; for discrete high‑level choices (strategy, tool), DQN variants or categorical policies work well. On‑policy PPO remains robust for tightly coupled environments if simulation speed permits. Incorporating model‑based elements is especially beneficial in CAM: a learned or mechanistic material removal model and force predictor enable lookahead planning, either via model‑predictive control or imagination rollouts that improve sample efficiency.

Geometry‑aware networks are critical. Graph neural networks can process toolpath graphs or CAD feature adjacency, 3D convolutions work over multi‑dexel or octree fields, and implicit encoders (SDFs) provide smooth, resolution‑independent geometry signals. Curriculum learning helps with stability and generalization: start with forgiving 2.5D tasks, then progress to 3+2 strategies and full **5‑axis** orientation planning; begin with aluminum and move to challenging nickel alloys as policies mature. Finally, **distributional RL** improves risk awareness by modeling return distributions, which is vital when edge events—like chatter or thermal runaway—carry outsized cost. The overall recipe is a hybrid: offline pretraining from logs and imitation, physics‑informed models for lookahead, and hierarchical policies tuned for both discrete and continuous decisions, with a curriculum that stretches capability while protecting safety.

• Offline RL and imitation from historical CAM and simulation logs.
• Off‑policy continuous control (SAC/TD3) and discrete selection (DQN/categorical).
• Model‑based RL using fast MRR and force predictors for lookahead.
• Geometry‑aware networks (GNNs, 3D convs, implicit SDF encoders).
• Curriculum learning from 2.5D to complex 5‑axis, and from soft to hard materials.
• Distributional RL for tail‑risk management.

Data, simulators, and integration into production CAM

Data and simulators

CAM‑grade RL lives or dies by simulator fidelity and data coverage. A high‑speed, multi‑dexel stock update engine is the backbone, delivering accurate engagement and material removal rate at millisecond scales. Overlay mechanistic force models—such as Kienzle or extended cutting coefficients—and **chatter stability maps** to emulate cutting physics credibly. For breadth, generate synthetic corpora by procedurally creating parts with parametric pockets, fillets, bosses, ribs, and freeform patches; randomize tools, holders, stick‑outs, and materials to promote robustness. Domain randomization helps policies avoid overfitting to a single shop configuration and prepares them for variability across machines and fixtures. Where full‑fidelity physics is too slow, learned surrogates step in: neural predictors for surface roughness, forces, and thermal load can be trained on high‑fidelity runs, then deployed for fast inner‑loop feedback during policy updates.

Uncertainty quantification is essential when leaning on surrogates. Techniques like ensembles or Monte Carlo dropout provide confidence bounds so shields can tighten when predictions are unreliable. Data pipelines should merge sources: historical G‑code with measured cycle time and tool life, CAM exports with strategy metadata, simulation logs with force/temperature traces, and sensor streams from the shop floor (power, vibration, temperatures via MTConnect or OPC UA). Curate datasets with clear provenance, capturing machine/controller versions, tool batch and coating, coolant type, and workholding notes; the policy will only generalize as well as the data is diverse and labeled. A practical target is a simulator capable of thousands of steps per second for 2.5D tasks and hundreds for 5‑axis, with interchangeable physics modules to trade speed for fidelity depending on training phase.

• Multi‑dexel engines for fast, accurate in‑process stock and engagement.
• Mechanistic forces and chatter maps to ground realism.
• Synthetic corpora and domain randomization for robustness.
• Learned surrogates with uncertainty to accelerate training safely.

Safety and verification

Safety layers must be “always on.” Every environment step should run collision and gouge checks against tools, holders, and fixtures; tolerance analyzers should verify that proposed passes can meet geometric and surface specs given scallop and deflection predictions. For 5‑axis, reachability and kinematic feasibility filters ensure axis limits, velocity, acceleration, and **jerk bounds** are respected, and that singularities are avoided. Safe exploration is achieved by projecting actions onto feasible sets, using **runtime shields** that either clip parameters or request alternative sub‑actions from the policy. On‑machine pilots should begin with low‑risk adjustments—feed overrides within narrow bands—while logging rich telemetry to refine models. If confidence metrics, such as predictive uncertainty or deviation from known safe regimes, exceed thresholds, the system should automatically fall back to a deterministic baseline and, when applicable, roll back to prior settings within the NC program.

Operationalizing these safeguards requires careful software architecture. Integrate verification services as callable micro‑engines: collision/gouge checker, tolerance predictor, chatter/stability assessor, and kinematic feasibility evaluator. Policies interact with these services through a standardized API that returns both a verdict and gradients or sensitivities where available, enabling smart action repair. Human‑in‑the‑loop protocols cement trust: programmers can “lock” constraints (e.g., max scallop, min standoff) and approve RL suggestions in a diff‑like view that highlights expected changes in **force margin**, cycle time, and surface metrics. Over time, as the system demonstrates reliable adherence to constraints and stable performance gains, exploration budgets can widen under governance oversight.

• Always‑on verification for collision, tolerance, chatter, and kinematics.
• Safe exploration via action projection and runtime shields.
• Fallback/rollback with deterministic baselines and confidence gating.

Deployment patterns

Introducing RL into CAM is as much about workflow as algorithms. A lightweight path is a CAM plugin that proposes strategies and parameters while the human remains in the approval loop. The UI can present ranked alternatives with predicted cycle time, wear impact, and surface quality, plus indicators for constraint margins. Autonomy should grow in stages: first, parameter optimization on existing paths; next, macro/path pattern selection; and finally, full toolpath synthesis for bounded operation classes. Throughout, close the loop with shop‑floor feedback. Ingest **MTConnect/OPC UA** signals—spindle load, vibration, coolant temperature—to update the digital twin and periodically fine‑tune policies. Align training with post‑processing realities by modeling controller‑specific G‑code constraints during training: arc linearization tolerances, look‑ahead buffer behavior, smoothing filters, and jerk limits so policies don’t propose paths your machine will later distort.

Machine diversity complicates deployment; account for it explicitly. Maintain profiles for each machine/controller pair—motion limits, interpolation quirks, supported G/M codes—and present these as part of the state so policies can specialize. Tool libraries and fixture catalogs should be versioned and tied to job contexts. On the shop floor, phased rollout reduces risk: enable RL for a constrained class (e.g., aluminum roughing on a specific vertical mill) with strict guardrails and metrics; expand scope only after consistent gains and clean audits. To maximize adoption, ensure explainability: side‑by‑side diffs of toolpaths, histograms of predicted forces versus baseline, and narrative rationales help programmers trust the recommendations.

• Plugin mode with human approval and constraint locks.
• Autonomy ladder: parameter tuning → macro selection → synthesis.
• Feedback loop using shop telemetry to update the digital twin.
• Post‑processing awareness for arcs, look‑ahead, smoothing, and jerk limits.

KPIs and governance

Governance ensures that enthusiasm doesn’t outrun rigor. Define clear KPIs before deployment: cycle time, surface Ra and scallop targets, geometric tolerance conformance, **tool life**, energy per part, scrap rate, and first‑article success. Measure not just averages but distributions, especially tail events like chatter hits or tolerance excursions. Evaluation should include A/B trials on hidden lots, cross‑part and cross‑machine generalization tests, and stress cases (thin walls, deep cavities, long stick‑outs). Track the policy’s behavior over time, ensuring improvements persist across shifts, tool batches, and machine maintenance cycles. Where possible, maintain deterministic baselines in parallel to detect drift and enable rapid rollback.

Traceability ties the whole system together. Version policies and datasets; record training configurations, simulator versions, and constraints. Link requirements from MBD/PMI directly to reward weightings and constraint thresholds so auditors can see how design intent maps to policy objectives. For explainability, support counterfactual replays—what would have happened under the baseline versus the new policy—and saliency overlays on geometry that reveal which regions drove decisions (e.g., tight radii flagged as high‑risk for **engagement angle** spikes). Finally, institute change control: a review board approves policy promotions to production, and every change is accompanied by a diff report covering KPIs, safety margins, and affected operation classes. This discipline is what turns promising prototypes into reliable production assets.

• KPIs: cycle time, surface, tolerance, tool life, energy, scrap, first‑article success.
• Evaluation: A/B on hidden lots, cross‑machine generalization, stress tests.
• Traceability: policy/dataset versioning, requirement linkage, explainable replays.
• Change control with promotion gates and audit trails.

Conclusion

RL can elevate CAM from heuristics to adaptive optimization

Reinforcement learning offers a practical path to move CAM from heuristic‑heavy programming toward **adaptive, learning‑driven optimization**. The key is fusion: marry RL with physics models, expert priors, and strict safety shields so the system learns within trusted boundaries. Rather than replacing programmers, RL augments them—suggesting parameter tweaks that reflect live engagement, recommending strategy families tuned to geometry and machine idiosyncrasies, and continuously improving as new data arrives. This shift doesn’t just shave seconds; it reshapes how shops respond to variability in parts, tools, and machines, enabling a level of responsiveness that static templates cannot match. With robust simulators, curriculum design, and governance, RL becomes a disciplined engineering method, not a gamble, and unlocks better throughput, quality, and sustainability with the equipment you already own.

Crucially, the approach scales. Start small—parameter tuning on a reliable 2.5D workflow—and grow toward 5‑axis orientation planning and closed‑loop adaptation. Each step builds technical depth (models, datasets, shields) and organizational trust (explainability, KPIs, rollbacks). The destination is a CAM stack that learns from every part cut, captures shop‑specific realities like controller smoothing or fixture compliance, and encodes those lessons into policies that new programmers can leverage on day one. Done right, RL turns variability from a liability into a competitive advantage.

• Physics‑informed learning bounded by safety shields.
• Human‑centered augmentation with transparent rationale.
• Scalable roadmap from 2.5D tuning to 5‑axis synthesis.

A pragmatic roadmap

Phase 1 focuses on low‑risk wins. Use imitation learning and offline RL to tune feeds, speeds, and step‑overs on 2.5D parts. Keep humans in the verification loop and enable conservative bounds via runtime shields. Leverage a fast **dexel simulator** and mechanistic force model to evaluate changes rapidly, and connect post‑processing constraints so suggestions are controller‑compatible. Establish KPIs and dashboards; demand that every suggested change shows expected cycle time savings, force margin improvement, or surface benefit, with uncertainty bars. This phase calibrates your data pipelines, simulator fidelity, and organizational workflows without touching geometry‑critical toolpaths.

Phase 2 introduces hierarchy. Let the policy choose strategy families (adaptive, spiral, trochoidal) and rest‑material targeting macros. Integrate learned surrogates for **force and thermal** predictions to accelerate training, but wrap them with uncertainty‑aware shields. Expand to varied materials and tool geometries. Start incorporating limited 3+2 positioning choices to prepare for full 5‑axis. Phase 3 tackles 5‑axis orientation planning with kinematic feasibility and chatter‑aware policies. The agent outputs orientation fields constrained by reachability and collision, while a low‑level controller modulates feed to maintain force within stability margins. Close the loop with sensor adaptation: spindle power and vibration streams refine the digital twin, and the policy periodically fine‑tunes to track machine aging and tooling changes. Across all phases, maintain deterministic baselines and a promotion process that requires clean A/B gains and safety adherence.

• Phase 1: imitation + offline RL for parameter tuning in 2.5D with human approval.
• Phase 2: hierarchical strategy selection and rest‑material targeting with physics surrogates.
• Phase 3: 5‑axis orientation planning, chatter‑aware control, and closed‑loop adaptation.

What to watch

The most common pitfalls are predictable but avoidable. Data quality and simulator fidelity determine whether policies learn transferable behaviors or overfit to artifacts. Invest in validation suites that compare simulator predictions against instrumented cuts, especially for force, temperature, and surface finish. Safe exploration is non‑negotiable; ensure shields are fast and conservative, and use distributional RL where tail events are costly. Generalization across machines and materials requires explicit modeling of context—don’t hide controller quirks or tool coatings from the state. Finally, governance is a feature, not overhead: without versioning, requirement linkage, and change control, it’s hard to justify promoting policies to production, no matter how promising lab results appear.

Watch for subtle failure modes: policies gaming rewards by increasing air moves to reduce force spikes, surrogate drift when retrained on biased samples, or post‑processors linearizing arcs and degrading surface quality the policy expected. Counter these with reward audits, uncertainty‑aware training, and post‑processing simulation in the loop. Provide engineers with **saliency visualizations** so they can see where the policy is “looking” on the geometry and intervene early if attention is misplaced. Continuous monitoring and periodic red‑team evaluations—deliberately constructed stress parts—keep the system honest and evolving in the right direction.

• Simulator fidelity validated against instrumented cuts.
• Safe exploration and tail‑risk awareness.
• Explicit context modeling for machines, tools, controllers.
• Governance disciplines and post‑processing in the loop.

Call to action

The first steps are straightforward and actionable. Mine your CAM and G‑code history for operations with repeat volume and clear KPIs—aluminum pockets, common rest‑mill patterns, or recurring finishing passes. Stand up a fast, verified dexel simulator with mechanistic forces and chatter maps, and wrap it with collision/tolerance/kinematic shields. Pilot RL in a constrained operation class where human‑in‑the‑loop approval is easy and consequences are low. Iterate quickly: propose, simulate, verify, approve, cut, and learn. Maintain a deterministic fallback until the policy demonstrates consistent wins and stable safety margins. As you scale, fold in telemetry via **MTConnect/OPC UA**, refine the digital twin, and expand autonomy deliberately along the roadmap.

The payoff is a CAM workflow that gets smarter with every part, balancing **cycle time**, **quality**, and **tool life** automatically while respecting safety and machine realities. Shops that cultivate this capability will adapt faster to new materials, geometry complexity, and supply variability, turning learning into a competitive moat. Start small, measure ruthlessly, and let data—not dogma—guide the journey.

• Start with history and high‑leverage operations.
• Build a fast, shielded simulator and integrate verification.
• Pilot RL in narrow scopes with human approval and clear KPIs.
• Close the loop with telemetry and periodic fine‑tuning.