Skip to content

TanGO: Training-Free 3D Editing via Tangent-Space Guidance and Optimization

Conference: ECCV2026
Paper: ECCV
Code: https://github.com/siw00-lim/TanGO
Area: 3D Vision
Keywords: 3D editing, training-free, optimal control, flow matching, tangent-space guidance

TL;DR

TanGO casts text-driven editing of a VecSet-based flow-matching 3D generative model as an instantaneous one-step optimal control problem solved at every ODE step: the per-token steering gain is determined by the directional mismatch between source- and target-conditioned velocity fields (a vMF negative log-likelihood, i.e. \(1-\cos\theta_i\)), and the closed-form solution pushes the tokens that must change while suppressing those that must be preserved โ€” no masks, no fine-tuning, no gradient-based optimization. On the authors' TanGOEdit benchmark it reaches 0.2301 CLIP-T, 0.7679 CLIP-I and 0.6510 DINO-I, beating FlowEdit and AnchorFlow, at roughly 28.7s per edit.

Background & Motivation

The foundation of 3D generation has turned over within two years: from DreamFusion-style pipelines that lift 2D diffusion priors into 3D via SDS gradients, to native 3D foundation models such as TRELLIS, Hunyuan3D, TripoSG and the VecSet-based generators. These new models no longer rely on an external 2D renderer for scoring; they perform diffusion or flow matching directly in a 3D latent space, which in principle leaves an editable latent state behind. Most of them, however, adopt structured latent representations: VecSet represents an object as 4096 latent tokens (Hunyuan3D 2.1 is the default backbone here) whose tokens share global context through self-attention. Precisely because of that global interaction, VecSet has been regarded as a "relatively global" representation, apparently ill-suited to localized editing โ€” perturbing a token to reshape a wing seems liable to leak into the whole body. Many training-free editing methods therefore prefer to fall back on low-level representations such as voxels.

The prevailing recipe for training-free editing is FlowEdit's velocity-difference scheme: at the editing state \(X_t^{FE}\) the model is run twice, once under the source condition and once under the target condition, and the difference

\[\Delta v = v_{\mathrm{tar}} - v_{\mathrm{src}}\]

drives the editing trajectory. The flaw that motivates every design in this paper is that although \(\Delta v\) inherits the token structure of VecSet and has a value for every token, prior methods never actuate it at the token level โ€” they multiply the whole velocity difference by a single globally shared scaling factor, so editable and preserved regions are perturbed together. Fig. 2 of the paper shows the consequences: FlowEdit and AnchorFlow either under-edit (the requested part simply does not appear) or spread the change into neighbouring parts, producing mesh tearing, surface collapse and loss of fine structure, so that even the source identity that should be untouched is not preserved; across the five edit categories (addition, replacement, removal, pose change, style change) their CLIP-I and CLIP-T scores stay markedly low. More importantly, the authors' empirical analysis of Hunyuan3D 2.1 contradicts the "VecSet is global" intuition: visualizing the influence of individual tokens shows each token's geometric effect concentrated on a specific part (wing, tail, arm, facial region) rather than spread over the object; only a subset of the 4096 tokens is actually active when generating a given object, and most tokens have a locality score above 0.96. The model therefore does not lack locality โ€” what is missing is explicit per-token actuation, since a control signal applied uniformly across tokens wastes that locality.

This makes the question very concrete: if different tokens correspond to different local geometry, editing should not apply the same strength to all of them, but should amplify the signal where change is wanted and suppress it where preservation is wanted โ€” without relying on manual masks, extra training, or gradient updates on mesh parameters. Core idea: replace "multiply the whole trajectory by one global scale" in training-free 3D editing with "allocate control gains per token in the tangent space" โ€” a one-step optimal control law with a quadratic energy penalty yields the gain in closed form, a vMF directional discrepancy between source and target velocities defines each token's demand, and mean-gain normalization pins the guidance energy along the trajectory.

Method

Overall Architecture

TanGO takes a source mesh plus a text instruction describing the desired edit (together with the source condition image/text) and outputs an edited mesh with texture. It updates no pretrained weights and performs no back-propagation: editing happens on the ODE sampling trajectory of a pretrained flow-matching 3D model โ€” at every step the model predicts two velocity fields, \(v_{\mathrm{src}}\) and \(v_{\mathrm{tar}}\), under the source and target conditions respectively, and TanGO then answers two questions that prior methods leave coupled: (i) which tokens should be actuated (localization across tokens), and (ii) how strongly they should be actuated (trajectory-level guidance energy). The first is answered by the per-token directional mismatch โ€” if the two directions agree, the token is already heading toward the target and needs no push, whereas larger mismatch means stronger actuation is needed. The second is answered by a closed-form control law with an energy penalty, after which mean-gain normalization stabilizes the total energy across steps so that guidance does not fluctuate over the 50-step integration. The resulting latent state is decoded directly into a mesh; since VecSet backbones have no native texture pipeline, TanGO appends a stage of multi-view rendering, missing-texel inpainting and texture baking to turn the geometry into a renderable asset.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    A["source mesh + text edit instruction"] --> B["vMF directional discrepancy<br/>per-token source/target velocities โ†’ d_i"]
    B --> C["instantaneous one-step optimal control<br/>closed-form gain g_i = d_i / ฯ"]
    C --> D["mean-gain normalization<br/>ฮป_eff = ฮปยทฮท / (แธก + ฮต)"]
    D --> E["per-token steering update<br/>50-step ODE integration"]
    E --> F["edited mesh"]
    F --> G["multi-view texture baking<br/>MV-Adapter โ†’ UV map โ†’ inpainting"]

Key Designs

1. vMF directional discrepancy: decide whether a token should change by direction, not by magnitude

Using the magnitude of the velocity difference \(\lVert v_{\mathrm{tar},i} - v_{\mathrm{src},i}\rVert\) as the criterion for "should this token change" is unstable: velocity magnitudes vary widely with timestep, asset scale and model confidence, so the same token can differ by an order of magnitude across \(t\), and a large magnitude reflects the scale of the current timestep rather than an editing requirement. The authors therefore compare directions: both per-token velocities are normalized onto the unit hypersphere and their cosine similarity \(\cos\theta_i = \hat v_{\mathrm{src},i}^\top \hat v_{\mathrm{tar},i}\) serves as a scale-free indicator of whether token \(i\) is already following the target-conditioned flow. To give this quantity a principled interpretation, the target-direction unit vector is treated as a von Mises-Fisher directional observation with mean direction \(\mu\) equal to the source direction and concentration \(\kappa\); its negative log-likelihood, up to constants independent of the observation, is proportional to \(\kappa(1-\cos\theta_i)\), which is taken directly as the token's demand \(d_i(t)\) after absorbing the ratio \(\kappa/\rho\) into the global scale \(\lambda\) used later:

\[d_i(t) = 1 - \cos\theta_i(t) = 1 - \hat v_{\mathrm{src},i}(t)^\top \hat v_{\mathrm{tar},i}(t)\]

This definition satisfies the three properties the authors set for themselves. It is scale-invariant, since only normalized directions are used; it is bounded, with \(d_i \in [0,2]\), so no token can produce a spurious spike; and it is geometrically consistent, because \(\lVert \hat v_{\mathrm{src},i} - \hat v_{\mathrm{tar},i}\rVert^2 = 2d_i\) makes it proportional to the squared distance between the two unit directions. When the two conditional velocities point the same way (\(\theta_i \approx 0\)) the token is already moving toward the target, the demand approaches zero, and the control holds it at the source state; when they are strongly misaligned (\(\theta_i\) near \(\pi\)) the token must change and the demand approaches its upper bound of 2. A global scaling factor has no such token-to-token discrimination, and an inner-product-style gain lacks normalization โ€” exactly the alternatives compared in the ablation on per-token gain design.

2. Instantaneous one-step optimal control: write "how much to change at each step" as a closed-form solution with an energy penalty

Given the demand, the strength still has to be decided, and control must not be spent along directions orthogonal to the target direction โ€” those perturbations are precisely what degrades preserved regions. TanGO treats each step as an instantaneous control problem: the control input \(u_i(t)\) should maximize first-order progress along the target direction \(\Delta v_i(t)\) while a quadratic term penalizes excessive intervention, and \(u_i\) is additionally constrained to lie in the subspace spanned by \(\Delta v_i(t)\):

\[\max_{u_i}\ d_i(t)\,\langle u_i,\, \Delta v_i(t)\rangle - \frac{\rho}{2}\lVert u_i\rVert^2 \qquad \text{s.t.}\quad u_i \in \mathrm{span}\big(\Delta v_i(t)\big)\]

This is what "tangent space" means in the title: the velocity field lives in the tangent space of the latent-state manifold at \(X_t\), and \(\Delta v_i(t)\) is the only direction in that tangent space that directly transfers the source flow toward the target flow. Restricting the control to \(\mathrm{span}(\Delta v_i)\) is a minimal-intervention principle โ€” go only along the direction that can reach the target โ€” and it rules out at the source the orthogonal perturbations that would damage preserved regions. Writing \(u_i = g_i \Delta v_i\) turns the objective into a concave quadratic in \(g_i\), whose closed-form solution is

\[g_i^*(t) = \frac{d_i(t)}{\rho}, \qquad u_i^*(t) = \frac{d_i(t)}{\rho}\,\Delta v_i(t)\]

The solution splits editing cleanly in two: the scalar gain \(g_i\) only allocates strength across tokens (it depends solely on directional mismatch and is insensitive to magnitude), while \(\Delta v_i\) keeps the full transformation direction and amplitude that actually reshape the geometry. The entire control law is thus determined once the demand \(d_i(t)\) is specified โ€” which is exactly what design 1 provides. Compared with AnchorFlow, which also performs training-free 3D editing, there is no gradient-based optimization loop over an anchor-alignment loss and no mask: every step, every token reduces to an analytically computed scalar, which is also why the per-edit runtime (28.73s) stays at the level of FlowEdit and AnchorFlow with almost no additional overhead.

3. Mean-gain normalization: keep the guidance energy from drifting over the trajectory

The gains \(g_i(t)\) are per-token, but their mean \(\bar g(t) = \frac{1}{N}\sum_i g_i(t)\) fluctuates along the trajectory: at timesteps where the overall directional mismatch is small the total control energy is squeezed too weak and the edit under-realizes, while at other steps the mismatch is large enough that the control becomes aggressive and destabilizes the mesh structure. Over a 50-step integration this drift accumulates, ending as "the requested change is incomplete and untouched parts get distorted." The authors' remedy is deliberately restrained: the relative allocation across tokens (already fixed by designs 1 and 2) is left alone, and only the overall strength is rescaled to a target energy level \(\eta\):

\[\lambda_{\mathrm{eff}}(t) = \lambda \cdot \frac{\eta}{\bar g(t) + \varepsilon}, \qquad u_i(t) = \lambda_{\mathrm{eff}}(t)\,g_i(t)\,\Delta v_i(t), \qquad \dot x_t^i = v_{\mathrm{src},i}(t) + u_i(t)\]

with \(\varepsilon\) only preventing division by zero. This fully decouples the per-token relative strength (which follows the directional mismatch) from the trajectory-level total strength (which is pinned by \(\eta\)). In the ablation, replacing \(\lambda_{\mathrm{eff}}(t)\) with a fixed constant \(\lambda\) causes under-editing at some timesteps โ€” a request such as "make the rock monster hold a sword", which requires a large deformation, simply fails โ€” whereas restoring normalization yields stable edits without collateral damage to surrounding geometry, confirming that this step is not optional decoration.

4. Multi-view texture baking: give VecSet models the native texture pipeline they lack

VecSet backbones generate geometry; even if the latent-space edit is perfectly correct, the decoded mesh carries no usable texture, and a 3D edit only becomes a practical asset once it is textured. After editing finishes, TanGO attaches a stage that is fully decoupled from everything above: MV-Adapter renders multi-view consistent images of the edited geometry, UV/texture maps are built from them, a large-mask image inpainting model (the resolution-robust Fourier-convolution method cited in the paper) fills in the texels that are missing or occluded in the renderings, and the texture is baked back onto the edited mesh. Keeping this a separate stage rather than folding it into the latent editing loop matters because it participates in no editing decision: swapping in another multi-view generator or inpainting model works just as well, which leaves the control law โ€” the paper's core contribution โ€” independently evaluable, with texture quality depending only on the surrounding tools.

A Worked Example

The following walks one concrete input through the pipeline to show how per-token allocation actually happens. The instruction is "add the Ruyi Jingu Bang to Wukong's back", the backbone is Hunyuan3D 2.1, the latent state has 4096 tokens, and the edit integrates 50 steps (from \(n_{\max}=41\) down to \(n_{\min}=1\)).

At some intermediate step \(t\) the model predicts the velocity field twice, once under the source text and once under the target text. For a token on the back, the target condition asks for a staff-like structure to appear there while the source prediction still describes the existing armour, so the two unit directions are nearly opposite, \(\cos\theta_i \approx -0.3\) and hence \(d_i \approx 1.3\). For a token on the torso, both conditions predict "keep this armour as it is", so \(\cos\theta_i \approx 0.98\) and \(d_i \approx 0.02\) โ€” it is barely pushed at this step. Suppose the mean over all tokens is \(\bar g \approx 0.1\); under the default \(\lambda=5\), \(\eta=0.2\), normalization scales the overall strength up to \(\lambda_{\mathrm{eff}} = 5 \times 0.2 / 0.1 = 10\). If at another step the overall mismatch grows and \(\bar g\) rises to 0.4, \(\lambda_{\mathrm{eff}}\) automatically drops to 2.5. Note that the ratio between tokens does not change โ€” the back token is still roughly 65 times stronger than the torso token โ€” only the global force at that step does. Integrating step by step down to \(n_{\min}=1\) yields a latent state that is decoded into a mesh and handed to multi-view baking for texturing.

(Note: the values of \(\cos\theta_i\) and \(\bar g\) above are illustrative of the order of magnitude, computed directly from \(d_i = 1-\cos\theta_i\) and \(\lambda_{\mathrm{eff}} = \lambda\eta/(\bar g+\varepsilon)\); they are not measured statistics from the paper. The paper's default hyper-parameters are \(\lambda=5.0\) and \(\eta=0.2\).)

Loss & Training

TanGO is training-free: there is no loss function, no gradient update and no parameter fine-tuning. The only thing being "optimized" is the per-step control objective of design 2, which is solved analytically, so the editing process is nothing more than a forward ODE integration with a per-token correction term. Implementation settings: \(T=50\) integration steps from \(n_{\max}=41\) to \(n_{\min}=1\); classifier-free guidance scales \(s_{\mathrm{src}}=3.5\) and \(s_{\mathrm{tar}}=7.5\) for the source and target branches; global scale \(\lambda=5.0\) and target energy \(\eta=0.2\); the final edited latent \(X_{\mathrm{edit}}^0\) is decoded directly into 3D space, and all experiments run on NVIDIA A100 GPUs.

Key Experimental Results

Main Results

The evaluation benchmark is the authors' TanGOEdit: 100 high-quality editing samples built by selecting assets with high aesthetic scores from Objaverse-XL, TRELLIS-500K and Google Scanned Objects (GSO) and using Qwen 2.5 VL to generate diverse editing instructions, covering both rigid and non-rigid edits. Three metrics are used: CLIP-T measures semantic alignment between rendered views of the edited result and the target text, while CLIP-I and DINO-I measure visual and feature-level similarity to the source condition image, i.e. fidelity. The comparison (TanGO at its defaults \(\lambda=5\), \(\eta=0.2\), 50 integration steps) is:

Method DINO-I โ†‘ CLIP-I โ†‘ CLIP-T โ†‘
MVEdit 0.5861 0.4994 0.1289
EditP23 0.5838 0.4971 0.1313
FlowEdit 0.6127 0.7205 0.2081
AnchorFlow 0.6426 0.7492 0.2124
TanGO (Ours) 0.6510 0.7679 0.2301

Against the strongest baseline, AnchorFlow, TanGO gains 0.0177 in CLIP-T, 0.0187 in CLIP-I and 0.0084 in DINO-I. The CLIP-T gain indicates tighter correspondence between the edit and the instruction, while the DINO-I / CLIP-I gains indicate that source identity and visual structure are better preserved; both rising together is exactly the balance per-token allocation is meant to achieve. Note that MVEdit and EditP23 sit at a CLIP-I level of only 0.49โ€“0.50: they are multi-view reconstruction-style editors rather than latent-trajectory editors, so this difference in family should be kept in mind when reading the cross-method comparison.

A user study (Table 2) gives preference evidence in the same direction, with participants favouring TanGO on prompt alignment, visual quality and shape preservation:

Method Prompt Alignment Visual Quality Shape Preservation
AnchorFlow 21% 16% 13%
TanGO (Ours) 79% 84% 87%

The largest margin is shape preservation (87% vs 13%), suggesting that per-token suppression does stabilize preserved regions. In addition, on a separate 150-sample mask-aware benchmark (100 samples from Edit3DBench plus 50 TanGOEdit samples annotated with masks in Blender) the authors report that TanGO outperforms MVEdit, EditP23, FlowEdit, AnchorFlow, VoxHammer and Nano3D on 3D-native text-shape alignment and mask-aware geometric preservation metrics including Uni3D_txt, CD_preserve and NC_preserve. This protocol is separate because 3D geometric preservation metrics require ground-truth edit masks, which the full TanGOEdit benchmark does not provide. โš ๏ธ These numbers are detailed in the supplementary material; no concrete values appear in the main paper.

Ablation Study

Config Result Note
Full TanGO (\(\lambda=5,\eta=0.2\)) Best-performing region on all metrics full model
w/o gain normalization (\(\lambda_{\mathrm{eff}}\) fixed to a constant \(\lambda\)) Guidance too weak at some timesteps causing under-editing (target shape not realized), too aggressive at others harming structure Cannot maintain consistent steering strength along the trajectory; per-token relative weights are unchanged, only the total energy runs loose
Global scaling (per-token gain removed) Worse than TanGO Falls back to one shared strength for all tokens โ€” the very problem this paper addresses
Magnitude gain \(\lvert v_{\mathrm{tar},i}-v_{\mathrm{src},i}\rvert\) Worse than TanGO Affected by velocity magnitude and timestep; not scale-invariant
Inner-product gain \(\langle v_{\mathrm{src},i}, v_{\mathrm{tar},i}\rangle\) Worse than TanGO Unnormalized and not bounded
\(\lambda \in \{1,2,3,5,7,10\}\) ร— \(\eta \in \{0.05,0.1,0.2,0.3,0.5\}\) CLIP-I and CLIP-T both peak at \(\lambda=5,\eta=0.2\), with smooth variation across settings No spikes or drops; robust to moderate hyper-parameter perturbation
Backbone swapped to TripoSG Still performs the semantic edit and beats AnchorFlow on both 2D alignment and mask-aware 3D preservation metrics Per-token actuation is not tied to the specific structure of Hunyuan3D 2.1

The efficiency comparison (Table 3) shows that per-token control costs almost nothing extra:

Method MVEdit EditP23 FlowEdit AnchorFlow TanGO (Ours)
Time per edit (s) 632.45 59.32 28.13 28.76 28.73

โš ๏ธ Full numbers for the per-token gain design and the cross-backbone results are likewise in the supplementary material; the main paper reports only the direction of the conclusion.

Key Findings

  • Per-token gain design and mean-gain normalization are two separate and separately necessary things: the former decides which tokens are pushed, the latter how hard the trajectory pushes overall. The ablation shows that removing normalization produces under-editing, the most direct failure evidence, while replacing the per-token demand with global scaling, magnitude or inner-product gains all do worse โ€” so a bounded, scale-invariant directional discrepancy is what makes the mechanism work, not just any token-level reweighting.
  • Fidelity and text alignment can improve together: editing methods usually trade off "changing enough" against "preserving enough", yet TanGO is highest on all three metrics and shows its largest user-preference margin on shape preservation. Suppressing signals in preserved regions does not weaken the edit; it is a precondition for a stable editing trajectory, which corresponds exactly to the analysis that global scaling lets the two objectives constrain each other.
  • Hyper-parameters are not delicate: across the full grid of \(\lambda\) from 1 to 10 and \(\eta\) from 0.05 to 0.5 the metrics vary smoothly and the default point lies in a high-performing region, which the authors take as evidence that the method needs no fine tuning to be practical; they also acknowledge (Fig. 8(a)) that excessively large \(\lambda\) begins to degrade preservation.
  • Generalization to other VecSet backbones: swapped to TripoSG the method still edits successfully and beats AnchorFlow, and the authors observe that TripoSG results are geometrically smoother, attributing this to the reconstruction capacity of its 3D VAE rather than to TanGO's optimization process.
  • Efficiency on par with FlowEdit / AnchorFlow: about 28.7s per edit, one to two orders of magnitude faster than MVEdit (632s) and EditP23 (59s), showing that token-level control and normalization add negligible computation.

Highlights & Insights

  • Translating editing into a control problem with a closed-form solution is the "aha" moment: once the objective is written as first-order progress along the target direction minus a quadratic energy penalty under a span constraint, the per-token gain is necessarily proportional to the demand. The research question shifts from "how to design an editing loss" to "how to define a principled demand", which drastically narrows the search space and incidentally explains why no gradient optimization and no mask are needed.
  • Giving a heuristic quantity a probabilistic reading via the vMF negative log-likelihood: \(1-\cos\theta_i\) is just "how far apart the directions are", but reading it as the negative log-likelihood of a directional observation and absorbing \(\kappa/\rho\) into the global scale naturally yields the two design constraints of boundedness and scale invariance. "Fix the properties first, then find the definition" is a transferable move.
  • The normalization trick that separates relative allocation from total energy: \(\lambda_{\mathrm{eff}}(t)=\lambda\eta/(\bar g(t)+\varepsilon)\) preserves the ordering across tokens and only rescales the total; it transfers directly to any guidance framework whose per-sample or per-token weights drift over steps (temporal guidance in video editing, step-wise reward shaping in agents) at the cost of maintaining a single running mean.
  • An empirical result that overturns a stereotype: locality scores and per-token influence visualizations turn "VecSet is a global representation, hence unsuitable for local editing" into a measurable claim (most tokens have locality scores above 0.96), reminding readers that global attention does not imply globally distributed geometric influence.

Limitations & Future Work

  • The authors explicitly acknowledge that the ceiling on preserving high-frequency geometric detail is set by the representational capacity of the backbone 3D VAE, independently of the editing algorithm; the same effect appears in the cross-backbone experiment (TripoSG being smoother reflects its VAE's reconstruction capacity). More expressive latent representations or hybrid pixel-3D refinement are the suggested directions.
  • A structural gap in the evaluation: the main TanGOEdit benchmark has only 100 samples and no ground-truth masks, so 3D geometric preservation metrics can only be reported on a separately built, smaller mask-annotated subset, and the main paper gives no concrete values for them โ€” cross-method 3D preservation claims currently rest on the supplementary material.
  • The method depends on the source and target conditions sharing a backbone: the two velocity branches must come from the same flow-matching model, otherwise the geometry of \(\Delta v\) (a direction difference within one tangent space) does not hold. The cross-backbone experiment only covers TripoSG, which is also VecSet-based; other structured representations such as TRELLIS's SLAT are untested.
  • Using direction but not magnitude keeps the demand stable, at the cost of discarding information about how large a change is required: two tokens with the same directional mismatch but different deformation magnitudes receive the same gain. Whether a controlled magnitude term should be added on top of the directional term (for instance a magnitude modulation stratified by \(\lambda\)) is a natural thing to try.
  • Per-token control is currently recomputed at every step (two model forward passes per step), so the runtime matches FlowEdit rather than beating it; predicting or reusing \(\bar g(t)\) or the demand distribution at low cost could still compress it further.
  • vs FlowEdit: FlowEdit proposed inversion-free editing from the source-target velocity difference in a 2D latent space and is the direct intellectual ancestor of TanGO. The difference is that FlowEdit applies a global scale to the whole trajectory, whereas TanGO pushes control down to each VecSet token and adds a span constraint plus an energy term to the control. Fig. 2 of this paper shows that FlowEdit produces clear semantic artifacts in 3D, and it is among the baselines beaten in the main table.
  • vs AnchorFlow: AnchorFlow also performs training-free 3D editing but follows a "latent anchor consistency plus anchor-alignment loss" route, requiring an optimization-style update of the edited result and still relying on a global / timestep-dependent scaling schedule. TanGO keeps the anchor family's advantage of avoiding inversion while replacing the update with a per-step closed-form per-token gain, so it needs neither an optimization loop nor a mask; the 87% vs 13% gap in shape-preservation preference best illustrates the difference.
  • vs SDS / score-distillation methods (DreamFusion, Magic3D, ProlificDreamer): that family lifts 2D diffusion priors into 3D through gradients of a differentiable renderer, the editing signal comes from the difference of 2D model scores, and every step back-propagates into the 3D representation โ€” typically optimization-based, expensive and prone to oversaturation. TanGO does not render, distill or use a 2D prior at all: the guidance comes entirely from the difference between two conditional velocity predictions of the same 3D flow model, and editing is a forward-integrated analytic update. In short, SDS has a 2D teacher instruct a 3D student, whereas TanGO lets the 3D model tell itself where to go and how much each part should move.
  • vs VoxHammer / Nano3D: VoxHammer improves local editing by reusing inverted latents and cached features for preserved regions, and Nano3D extends FlowEdit into TRELLIS with connectivity-aware region merging; both lean on reusing preserved regions or partitioning them. TanGO differs by needing neither masks nor region partitioning, delegating locality to the model's own per-token influence, which makes cross-backbone transfer easier (it works on TripoSG out of the box).
  • vs Instant3dit: that approach performs editing as multi-view image inpainting followed by reconstruction, a heavy pipeline whose quality depends on the reconstruction; TanGO edits directly in the native 3D latent and only uses multi-view models for the final texture baking, which is peripheral rather than core.

Rating

  • Novelty: โญโญโญโญ Casting training-free 3D editing as one-step optimal control in the tangent space and deriving a closed-form per-token gain is a fresh, principled angle; the core ingredients (velocity-difference editing, token-level reweighting) are inherited from FlowEdit and attention-scaling work respectively, making this combinatorial innovation.
  • Experimental Thoroughness: โญโญโญโญ A self-built 100-sample benchmark plus user study, hyper-parameter sweep, backbone swap and runtime comparison give good coverage; yet the main benchmark lacks masks and the complete numbers for the 3D-native geometric metrics and gain designs live only in the supplementary, so the main paper cannot be verified on its own.
  • Writing Quality: โญโญโญโญ The chain from motivation to mechanism is clear (locality observation โ†’ per-token actuation โ†’ control law โ†’ demand definition โ†’ normalization) and the formulas are well restrained; the handful of key quantitative results pushed to the supplementary material (mask-aware evaluation, ablation numbers) weakens the self-containedness of the main paper.
  • Value: โญโญโญโญ The method is training-free, mask-free and costs the same as FlowEdit, making it directly usable in real 3D design workflows; its ceiling is bounded by the backbone 3D VAE, a realistic boundary shared by this line of work.