Amortized Constrained Flow MatchingSymmetry-aware grasp refinement and optimizer-trace warm starts
Maneva AI
Robot solvers repeat the same continuous search for every new query. ACFM puts a small learned flow in front of that search. The flow proposes a starting point. The classical stack still checks and decides.
The flow proposes. The checker decides.
A manipulation stack is a chain of specialists: a planner, a grasp generator, a motion solver, a controller. Each new query usually starts its search from a generic guess, even when very similar queries were solved before. A learned model can reuse that experience. If the model's output is trusted without checks, it can break every module after it.
ACFM keeps those two jobs apart. A small flow model learns to improve one continuous variable, such as a grasp pose or a whole trajectory. The way the variable is built keeps it well formed at every step. The existing checker or optimizer still makes the final call. Click a stage below to see what it does in each study.
Where ACFM sits in the stack
R Structural, by construction
Guaranteed by how a candidate is built. The network never has to learn these rules.
- A rotation updated through the SO(3) exponential stays a rotation.
- Actions rolled through the known dynamics give a model-consistent trajectory.
- A known symmetry group gives exact copies of a grasp.
B Verified, by checking
Needs an external checker. The flow only learns these implicitly from its training data.
- Collision avoidance and joint limits.
- Reaching the goal pose.
- Grasp validity and task preference.
Technical detail: the formal setup equations · paper Fig. 1
Write z for the learned variable, c for the context (object, gripper, start, goal, obstacles) and C(c) for the set the rest of the stack accepts. The feasible set splits into a structural part and a verified part:
From a seed z0, ACFM integrates a learned velocity field vθ(zs, c, s) over flow time s ∈ [0, 1] in M forward Euler steps. A realization map ρ turns each update into a point of R: a parameterization, a group action or a rollout. It guarantees only structural validity. A model-consistent trajectory can still pass through an obstacle, so B is left to the checker.
Supervision differs per study. Grasps learn from an analytic oracle that names the preferred member of a symmetric family. Trajectories learn from the iterates of a classical optimizer.
Collapse to learn, lift to cover
Many objects are symmetric. A square block looks the same after a quarter turn, so it has four equally good top grasps. A cylinder can be grasped from any side. The set of grasps that symmetry makes equivalent is called an orbit.
A refiner could be trained to predict every grasp in the orbit at once. Then it must also learn large turns, up to 180°, toward the far copies. ACFM instead collapses the training target to one grasp, so the learned correction stays small. At deployment it lifts the refined grasp back through the symmetry to get the other copies exactly, with no extra learning.
Square block, seen from above
Illustrative · exact geometrySquare grasp found
MeasuredMatch rate on 2,000 held-out contexts. Learned rows: mean of 5 training seeds (SE ≤ 0.8 points), 6k training steps. Four-pose methods are scored on all four outputs. Source: paper appendix, square top-grasp table.
Is the naive model just slow?
MeasuredYes. It reaches 97–98% only after 48k–96k training steps. ACFM is at 99.2% after 6k. The paper does not explain why the naive model learns slowly.
Match@4 versus training steps, seed 0, 2,000 contexts. Paper budget is 6k.
The grasp flow on a cylinder
On the cylinder the target depends on the context. The answer key T* is the grasp on the family that is close to the noisy proposal and also close to the gripper's current pose. The flow is trained to move from the proposal to T* in 16 small rotation and translation steps. Move the sliders to see how T* changes, then step through the flow.
Cylinder side grasp, seen from above
Illustrative · exact oracle, ideal flow pathCylinder results
Measured| Method | Valid@1 | Match@1 | 8 trials | Dist. (m) |
|---|---|---|---|---|
| Unrefined proposal | 0.023 | 0.003 | 0.018 | 0.135 |
| Fixed canonical grasp | 1.000 | 0.028 | 0.193 | 0.331 |
| Uniform grasp on orbit | 1.000 | 0.028 | 0.195 | 0.345 |
| Grasp flow (ACFM) | 0.993 | 0.847 | 1.000 | 0.019 |
Fixed and uniform grasps are always valid but match T* only by chance. The flow recovers the preferred angle from its inputs without scoring candidates.
400 held-out contexts, 16 proposals each. Flow row: mean of 5 seeds (SE ≤ 0.022). Valid = within 2 cm and 5° of any exact grasp. Match = same tolerance around T*. Source: paper Table 1.
What the demo shows
Recorded output. These are 16 held-out contexts from the trained seed-0 grasp model. Each step is the network's own pose after its SO(3) update. The faint line is the ideal path it was trained to follow. Errors and the valid and match tests are computed in 3-D on the recorded poses. The view is top-down, so only wrist yaw is drawn.
Seed 0 scores 0.990 valid and 0.763 match over 400 contexts (the 5-seed mean is 0.993 and 0.847). In these 16 contexts, 13 end within the match tolerance.
Explore mode. The answer key T* and the validity test use the paper's formulas, computed live. The flow path is the straight path the network is trained to follow, not a recorded network output. The view is top-down, so only wrist yaw is drawn. The paper's noise also tilts the gripper.
Technical detail: model, oracle and metrics equations · paper Figs. 3–4
The gripper is described in the object's own frame. The network reads 42 numbers: the current candidate pose (12), the initial gripper pose (12), two object dimensions and 16 Fourier features of flow time. It outputs angular and translational velocities ωm, um ∈ ℝ³. With M = 16 steps and Δs = 1/16:
The rotation update stays on SO(3), so every intermediate candidate is a valid rigid pose. For the cylinder the target minimizes
with d² = ‖Δp‖² + wR θ², wR = 0.04 (rotation weighted at 0.2 m/rad). For the square the target is the grasp nearest the proposal (λ = 0), which needs a turn of at most about 45°. The lift is the left action of the symmetry group: four exact copies for the square, eight at 45° for the cylinder.
Square ablation: aiming at one target instead of four accounts for about 51 points (a one-step network toward the nearest grasp reaches 60.6%). Refining over 16 steps instead of one accounts for most of the rest. Because the square model aims at the nearest grasp, it matches the task-preferred grasp only 67% of the time before the lift. Choosing among the copies is left to a downstream score.
Learn the path, not only the answer
A local trajectory optimizer needs a starting guess, called a warm start. Normally it gets random controls. Each solve also leaves behind a record of every intermediate trajectory it passed through: the optimizer trace.
The simplest learned warm start, Imitation Flow (IF), keeps only the first and last trajectory and learns that single jump. Shortcut Optimizer Flow (SOF) learns from the whole trace: the steps between iterates 1, 2, 4 and 8 apart, and from each iterate to the final answer. Both then get the same few optimizer steps and the same checks.
One optimizer solve, and what each method keeps
Illustrative · 2-D toy solved liveAbout this toy
A point robot moves left to right past two blocking obstacle pairs, like the arm task. Controls are rolled through the dynamics xk+1 = xk + Δt uk (48 steps), so every iterate is model-consistent. Your browser runs 16 Gauss–Newton iterations with line search, the same kind of solver the paper uses as teacher.
No learned model runs in this toy. The recorded 7-DOF rollouts from the trained models are shown below.
Training pairs per solve
Distinct pairs from one 16-iterate trace: gaps of 1, 2, 4, 8 (53 pairs) plus every iterate to the final one (16), minus 4 overlaps.
The real 7-DOF arm: recorded rollouts from the trained models
Measured · seed 0, reduced-scale runDrag to rotate the view.
| This scene | EE error | Pass? |
|---|
Each learned step changes only the 48 controls. The states and the arm pose are then recomputed by rollout, so every frame here is a pose the robot's dynamics can reach. After the learned steps, every method gets the same 4 Gauss–Newton steps.
16 test scenes from the seed-0 run at the budget-sweep scale (2,048 training traces, 40 epochs, smaller network). On all 512 test scenes this run reaches 43.9% (SOF), 9.6% (IF) and 6.6% (random start) after 4 optimizer steps. It is not the 16k-trace run behind the main table below. EE error is the distance from the end effector to the target at the last waypoint. Pass uses the paper's full test: under 5 cm, under 15°, no collision and no joint-limit violation at all 49 waypoints. Arm drawn at every 6th waypoint.
7-DOF arm: success after 4 optimizer steps
MeasuredPose success (%), mean ± SE over 3 seeds, 512 test contexts each, shared training traces. Success: final position error under 5 cm, orientation under 15°, no collision at 49 waypoints, no joint-limit violation. Teacher rows are raw optimizer endpoints after 16 or 64 steps, shown for reference. Source: paper Table 2 and appendix data-scaling table.
Two control experiments
Same architecture, endpoint only. Training SOF's network on endpoint pairs alone gives 59.2%, close to IF. The architecture and step-size input do not explain the gain.
Same 16 steps, straight line. A bridge trained on straight-line interpolation from seed to answer reaches 30.7%, with the same 16 learned updates. Extra learned steps alone are not enough.
With 32k traces IF improves more than SOF. The gap narrows from 21.9 to 16.2 points. Whether IF can close it with more data is open.
The warm start matters most when the optimizer budget is small
Measured · reduced scaleOne seed, 2,048 training traces, 512 test contexts, checkpoints selected on raw warm-start cost. Absolute levels are not comparable to the main table. No learned warm start succeeds without optimizer steps (0% at P = 0). The paper reports no wall-clock speedup: at comparable runtime SOF (M = 4) reaches 44.0% in 1.02 s and IF 44.5% in 0.91 s. Source: paper appendix, budget sweep.
Technical detail: secants, loss and deployment equations · paper Fig. 2
The learned variable is a state–action trajectory τ = (x0:N, u0:N−1). The teacher is a shooting Gauss–Newton / iLQR solver that records iterates τ⁽⁰⁾, …, τ⁽ᴶ⁾ with J = 16. Treating iteration j as time sj = j/J, any two iterates define a secant:
SOF predicts these secants conditioned on flow time and the interval, inspired by the step-size conditioning of shortcut models. It trains on skips k ∈ {1, 2, 4, 8} and on suffix-to-final pairs (τ⁽ʲ⁾, τ⁽ᴶ⁾):
At deployment every method moves only the actions and recomputes the states by rollout after every learned step, so each intermediate warm start is consistent with the dynamics. SOF deploys 16 steps with Δs = 1/16. Longer gaps are training targets only.
Why the trace can help: with affine dynamics and a strictly convex quadratic cost, exact Newton steps stay on the straight line from seed to optimum, and secants add no new directions. The arm cost has non-quadratic terms (kinematics, orientation, collision) and the teacher is approximate, so the correction direction changes across iterations. SOF also sees more training pairs per solve and inputs closer to the ones it visits at deployment. The paper does not isolate which effect explains the gain.
Arm task: first-order joint dynamics, Δt = 0.08 s, N = 48 steps, 35-dimensional context, two obstacles of two overlapping spheres each on the straight start-to-target line. 16,384 training contexts, all filtered to be solvable by a 64-iteration teacher. Network: residual MLP, width 512, 6 blocks, about 3.9M parameters.
| Method | Learned M | Optimizer P | Success % | EE (cm) | Rot. (°) |
|---|---|---|---|---|---|
| Random start | 0 | 4 | 7.2 ± 0.3 | 21.59 | 25.57 |
| Endpoint IF | 1 | 4 | 59.5 ± 1.5 | 6.05 | 14.12 |
| Endpoint IF, raw-cost checkpoint | 1 | 4 | 59.5 ± 0.7 | 6.06 | 14.02 |
| Endpoint-only SOF | 1 | 4 | 59.2 ± 2.0 | 6.61 | 14.93 |
| Endpoint bridge | 16 | 4 | 30.7 ± 6.5 | 13.36 | 23.82 |
| Finite-skip SOF (ACFM) | 16 | 4 | 81.4 ± 1.3 | 3.19 | 9.26 |
| Teacher J16 (reference) | 0 | 16 | 88.3 ± 0.7 | 3.25 | 8.78 |
| Teacher J64 (reference) | 0 | 64 | 92.3 ± 0.7 | 2.73 | 7.39 |
What this paper does not show
Both studies are controlled simulations. They measure how the choice of representation and supervision affects a learned proposal. They are not a system benchmark.
Grasp study
- The object frame, symmetry, grasp family and answer key are given exactly.
- Valid grasps are known in closed form, so the study does not show that learning is needed for these objects.
- Initial proposals are local perturbations of the known family.
- Validity means within 2 cm and 5° of an analytic grasp. It does not test reachability, collisions or grasp stability.
Trajectory study
- First-order joint kinematics, four spheres and an eight-point collision proxy that ignores link volume, self-collision and swept motion.
- Contexts are filtered to be teacher-solvable. Three seeds share one training set.
- The random start uses white-noise controls, not a straight line or a nearest stored solution.
- The 5 cm success tolerance is loose for precise manipulation.
- The paper reports solution quality at a fixed budget, not wall-clock savings.
Both studies
- Simulation only. No perception, contact or hardware evaluation.
- The learned flow never certifies its own output.
Next experiments
- Trajectories: a full-scale budget sweep against solver iterations and wall-clock time, with straight-line and nearest-solution starts.
- A comparison with GLENS-style iterate augmentation.
- Grasps: train on point clouds, where the object pose and symmetry axis must be estimated.
- Replace the analytic answer key with a learned or simulated grasp score.
Cite this work
@techreport{maneva2026acfm,
title = {Amortized Constrained Flow Matching for Robot Planning:
Symmetry-Aware Grasp Refinement and Optimizer-Trace Warm Starts},
author = {{Maneva AI}},
institution = {Maneva AI},
type = {White paper},
year = {2026}
}
About the data on this page
MeasuredEvery number with this badge comes from the paper's tables, which are built from the experiment repository's result files.
- Cylinder and square grasp results: 5-seed summary.
- Naive four-head training budget: single-seed sweep.
- Arm main table: 3-seed audit run, 16k and 32k traces.
- Budget sweep: reduced-scale single-seed run.
- Recorded cylinder flow paths: 16 held-out contexts from the trained seed-0 grasp model.
- Recorded arm rollouts: 16 test scenes from the trained seed-0 SOF and IF models of the reduced-scale run, with the teacher's trace for the same scenes.
What is illustrative
IllustrativeThese views explain the method. They are not results.
- Square demo: exact symmetry geometry. No network runs.
- Cylinder demo, explore mode: exact oracle and validity test. The flow path is the ideal training target, not a network output.
- Trajectory toy: a 2-D problem solved live, not the 7-DOF arm.

