arXiv is now an independent nonprofit! Learn more
License: CC BY 4.0
arXiv:2608.17564v1 [cs.CV] 18 Aug 2026

Where a New Concept Must Enter:
Entry Point Gates Cross-Task Usability in Unified Multimodal Models

Zongyang Qiu zqiuap@connect.hkust-gz.edu.cn Affiliation: The Hong Kong University of Science and Technology (Guangzhou)    Yihan Wu yw4788@columbia.edu Affiliation: Columbia University    Kaixuan Fan 1155246176@link.cuhk.edu.hk Affiliation: MMLab, CUHK    Bo Li bol8@Illinois.edu Affiliation: University of Illinois Urbana-Champaign    Hui Xiong xionghui@ust.hk Affiliation: The Hong Kong University of Science and Technology (Guangzhou)
Abstract

Unified multimodal models (UMMs) are motivated by the hope that understanding and generation reinforce each other but controlled ablations repeatedly find that adding a generation objective leaves understanding flat. Joint-training studies cannot settle the disagreement: with overlapping supervision, a gain cannot be attributed to the architecture rather than the data. To further investigate the relationship between the two directions in UMMs, we separate them by construction. A novel visual entity, a rendered 3D asset paired with a pseudo-word screened for absence from the frozen model’s behavior, is bound through exactly one task direction, and the untrained direction is then measured. We find that the channel is real in both directions, but the directions differ in kind: generation training installs a name the model can only match among candidates; understanding training installs one it can also produce. What governs cross-task usability is where the binding enters the shared computation. An alignment probe predicts export across 36 configurations (Spearman ρ=+0.68\rho=+0.68). That objective’s alignment term, maximized in closed form over activations with every weight frozen, makes a concept drawable when injected at layer 7 of 28 and is indistinguishable from the base model from layer 14 on, while the weight-based version of the same edit peaks at layers 10–14. In an observational series of four models, this window appears only where the understanding pathway is a semantic vision encoder, suggesting that unified weights are not enough: the two directions must share a semantic format at the entry point. Exploiting the rule, a mid-stack alignment objective acquires the concept for a 0.1%0.1\% relative loss of the model’s general text-to-image ability, against 41%41\% for the standard generative route. Our code is at https://github.com/Zane-ZYQiu/entry-point-umm.

1 Introduction

Two literatures disagree about unified multimodal models (UMMs). One motivates them by mutual reinforcement between understanding and generation. The other, when it runs controlled ablations, finds that adding a generation objective leaves understanding benchmarks flat or slightly worse (Wu et al., 2025a; Jiao et al., 2025; Tong et al., 2025). A 2026 paper still opens by calling the generation\rightarrowunderstanding direction “largely unexplored” (Su et al., 2026).

Both can hold at once, because they answer different questions. Whether joint training happens to move knowledge between tasks is a fact about objectives and data mixtures. Whether the architecture can move it is a fact about the model, and no joint-training ablation isolates it: the two tasks see overlapping data, so a gain cannot be attributed to a channel rather than to supervision. The question the field argues about is therefore not the question its experiments measure.

Refer to caption
Figure 1: What the model draws for “a photo of a {name}”. Rows are four novel concepts and the reference column shows a view of the asset each pseudo-word was bound to. On the left side, the base model has never seen the pseudo-word; a placebo that supplies another concept’s address at identical magnitude draws the wrong object; and a closed-form activation edit applied at layer 14 leaves the base model’s output untouched. On the right the binding lands inside the window: the same edit at layer 7 with every weight frozen; training the understanding direction alone; the standard generative route; and the proposed objective, an alignment loss at layer 14 with no generative gradient, for a 0.1%0.1\% relative loss of general text-to-image ability (§7). Where the binding enters, not how it is optimized, is what decides.

To fill this gap, we isolate the architectural question by construction. The concept is a specific 3D asset rendered from 60 viewpoints, paired with a pseudo-word screened for absence from the frozen model’s behavior. It is bound through exactly one task direction, and the other direction is then measured. No training example ever teaches the untrained direction, so any competence there arrived through the model. Under this protocol, the channel turns out to be real in both directions, but unequal in kind: a model trained only to draw the concept can pick its name out of a line-up and cannot produce the name, while a model trained only to caption it can also draw it.

The paper’s central result comes from placing the same binding at one position after another along a single axis: where it enters the computation that both tasks run. That axis orders effects which otherwise look unrelated (Table 3 in §5), and Figure 1 previews it. A binding that enters early enough into a pathway both tasks execute becomes usable in both. A binding that enters a private branch, a non-exporting carrier, or the readout does not, however well aligned it is at that site. Position is necessary but not sufficient: across four architectures the same intervention works only where the two directions already represent concepts in a common semantic format at that depth. The rule also pays rent: writing the binding mid-stack with an alignment objective, and no generative gradient at all, acquires the concept for a 0.1%0.1\% relative loss of the model’s general text-to-image ability, where the standard generative recipe costs 41%41\%.

Contributions.

  1. 1.

    We propose a contamination-free measurement of the cross-task channel, and a dissociation inside it: the channel is real both ways, but generation training confers the ability to match a name and not to produce it. Multiple-choice probes cannot see the difference, being passable by elimination; scoring production instead, by asking for the name with every candidate removed from the context window, splits all seven conditions by whether the recipe ever computed a language-model cross-entropy (§4).

  2. 2.

    We discover that entry point gates usability, and only in a common semantic format: an alignment probe predicts export across 36 configurations, but driving it to ceiling confers nothing, while an activation edit that maximizes the same alignment term in closed form confers 80%80\% of the trained gain and only inside a narrow window (§5). Across four models the window tracks what the understanding pathway encodes, semantic encoder yes and reconstruction codebook no, rather than backbone family or scale (§6).

  3. 3.

    We give a practical method: entering mid-stack with an alignment objective and no generative gradient acquires the concept while costing 0.1%0.1\% of general text-to-image ability, against 41%41\% for the standard generative route (§7).

2 Related work

Evidence on the cross-task channel.

Controlled ablations disagree about whether a generation objective helps understanding. Janus reports an average 4.44.4-point cost across the four benchmarks it tabulates under a shared visual tokenizer, and neutrality once the encoders are decoupled (Wu et al., 2025a); UniToken finds 0\approx 0 at matched per-task data on two backbones (Jiao et al., 2025); Liquid reports +2.1+2.1 on POPE in a 10M-per-task regime (Wu et al., 2026), a gain that MetaMorph’s data-ratio grid shrinks from +5.0+5.0 at 1M understanding examples to +0.6+0.6 at 4M and +0.4+0.4 at 7M (Tong et al., 2025); and UniMRG turns it reliably positive by changing the generation target to depth and segmentation maps (Su et al., 2026). Methods built to couple the two directions, RecA (Xie et al., 2026) and self-improvement loops (Qu et al., 2025; Mao et al., 2025), improve unified models but train both at once. In each case the channel is confounded with the data mixture, which is the gap a single-direction design closes. Three concurrent benchmarks measure the resulting incoherence from the outside, per model (Wang et al., 2026a), per visual concept (Wang et al., 2026b), and per question posed in either modality (Zhang et al., 2024; Chung et al., 2025). Their unit of analysis is a model and a score; ours is one newly bound concept and the depth at which it enters, so we can attribute a failure where a benchmark cannot.

Architecture, weight sharing, and alignment depth.

Unified models span shared-tokenizer early fusion (Chameleon Team, 2024; Wang et al., 2024), diffusion–LM hybrids (Zhou et al., 2025; Xie et al., 2025a; Xie et al., 2025b), decoupled encoders (Wu et al., 2025a; Chen et al., 2025), fully shared backbones (Wu et al., 2025b), Mixture-of-Transformers (Liang et al., 2025; Deng et al., 2025), and discrete diffusion (Li et al., 2026a; Xin et al., 2025), surveyed by Zhao et al. (2025). These labels are not a sharing axis: §6.2 measures the fraction of weights the two directions actually share in two of them and finds 0.500.50 against 0.870.87. On the alignment side, REPA accelerates diffusion training by aligning a denoiser’s internal states to a frozen external encoder and ablates the depth at which it does so (Yu et al., 2025), and we claim no novelty for alignment depth mattering. Their effect is graded and shallow, every depth helping substantially, and it is scored by the generation quality of the model that received the gradient, whereas ours is scored by a task that receives none and vanishes past a sharp cutoff. Their own table shows the distinction: from depth 6 to 16, linear-probe accuracy rises 66.271.166.2\rightarrow 71.1 while FID ends worse than it began, better alignment accompanying worse generation, the dissociation §5.1 makes central. LatentUMM argues concurrently that a shared latent space is not by itself enough and aligns the transformations into and out of it for round-trip consistency (Luo et al., 2026), and a parallel line argues on the generation side that a generator should be conditioned on semantically structured rather than reconstruction-optimal latents (Bi et al., 2026; Page et al., 2026; Li et al., 2026b), a neighboring conclusion to what §6 reaches about the understanding pathway.

Concept injection and knowledge localization.

DreamBooth (Ruiz et al., 2023) and Textual Inversion (Gal et al., 2023) inject concepts into generation-only models and have no understanding side; our embedding-only control is a textual-inversion variant and the shallow endpoint of the entry-point sweep. The applied counterpart in unified models is personalization, where a user concept must be both drawn and talked about (Zhong et al., 2026); those methods encode the concept as a learnable soft prompt, an embedding-level intervention that §5.2 measures directly and finds indistinguishable from the base model. MIKE benchmarks editing fine-grained entity knowledge into an MLLM, on the understanding side alone (Li et al., 2024), while ROME and MEMIT locate facts in specific MLP layers of language models (Meng et al., 2022; Meng et al., 2023), later unified as one preservation–memorization objective (Gupta et al., 2024), consistent with our finding that the shared expert’s MLP and not its attention is the substrate that exports (§4.2). None of these lines asks whether an edit made for one direction is legible to the other.

3 Concept injection experiment

Every experiment in this paper runs the same design (Figure 2). A novel visual concept is bound into a frozen unified model through exactly one task direction: either text\rightarrowimage generation or image\rightarrowtext understanding. The opposite direction receives no gradient and no training datum, and is then evaluated. Because nothing outside the model connects the two directions, any competence on the untrained side must have travelled through the model’s shared computation. What varies across sections is where and how the binding is written: the training objective (§4), the substrate that carries it (§4.2), and the depth at which it enters the stack (§5). This section fixes everything the experiments share.

Refer to caption
Figure 2: The contamination-free protocol. A novel entity (left) is bound through exactly one task direction, (a) generation or (b) understanding, and the opposite direction, which received no gradient and no datum, is then probed; the model’s shared blocks are the only path between the two.

3.1 Model, concepts, injection

Model.

BAGEL-7B-MoT (Deng et al., 2025), a Mixture-of-Transformers (Liang et al., 2025) with 28 decoder layers and hidden size 3584. Each layer carries a shared text/understanding expert (self_attn.{q,k,v,o}_proj, mlp.*) and a private generation expert (*_proj_moe_gen, mlp_moe_gen.*). Understanding runs the shared expert only; generation runs both.

Concepts.

We create 56 pseudo-named entities, each one Objaverse (Deitke et al., 2023) asset rendered in Blender from 60 training and 20 held-out viewpoints over disjoint azimuth ranges, with randomized lighting and backgrounds, paired with a pronounceable pseudo-word screened so the frozen model produces no consistent visual or lexical behavior for it (Figure 1). Concepts form seven disjoint groups of eight. Every number is measured within a group against a 24-wide retrieval bank of its own eight plus the next two groups, cyclically, so all groups sit at identical task difficulty.

Injection.

G-inject trains caption \rightarrow image with the rectified flow objective (Liu et al., 2023); U-inject trains image \rightarrow text with language-model cross-entropy. Adapters are LoRA (Hu et al., 2022), rank 32, with placement a controlled variable (§4.2). An adapter trained in one direction is evaluated with both branches active, so a failure to export is a failure of the model and not of the harness.

3.2 Metrics

Three terms carry the paper’s argument and are used with these fixed meanings throughout.

Entry point. The single site in the decoder stack at which a concept’s binding is written: the layer whose residual stream is edited, or at which an adapter’s alignment objective is read. Depth is reported as an absolute block index and, across architectures, as the relative depth (+1)/nlayers(\ell+1)/n_{\text{layers}}.

Export. Accuracy on whichever task direction received no gradient. Export is the only quantity this paper draws conclusions from; accuracy on the trained direction is reported to show that the binding was learned at all.

Matching versus production. Name matching is a 4-way forced choice with the candidate names shown in the prompt beside the image (chance 0.2500.250). Name production is the same decision with no candidate anywhere in the context window: each pseudo-name in the group is scored as a continuation of “\langleimage\rangle This is a {name}” in its own forward pass and the argmax is taken, with pointwise mutual information (PMI) cancelling the names’ differing priors (chance 0.1250.125 within a group of eight).

Every multiple-choice probe is satisfiable by matching, so we report matching and production separately throughout. An intervention that makes a name’s state resemble the image’s encoding passes a 4-way probe without the model being able to do anything else with the concept, and the escape hatches fail for the same reason: the reverse probe is that matching operation run backwards and scores 1.0001.000 for exactly the conditions one would want to exonerate, and the existence probe also has the name in the prompt. We therefore fixed a first-sub-word-only column of the production probe as the arbiter before running. An activation edit fires at the name’s own token positions, so it cannot alter the first sub-word, which is predicted from the state before the name begins; that column is immune by construction to the shortcut the probe detects. Nothing is sampled, so no decoding hyper-parameter enters (Appendix B).

Two further quantities recur. Identity (generation side) is 24-way DINOv2 (Oquab et al., 2024) top-1 retrieval of images generated from “a photo of a {name}” against held-out reference sets, chance 0.0420.042; it is scored under a second, architecturally independent encoder wherever it carries a depth claim (§5.2). TransferRate normalizes cross-task accuracy by what direct training achieves. Let AcrossA_{\mathrm{cross}} be accuracy on the untrained direction after cross-task injection, AdirectA_{\mathrm{direct}} accuracy on the same direction when it is trained directly, and AbaseA_{\mathrm{base}} the unmodified base model’s accuracy; then

TransferRate=AcrossAbaseAdirectAbase.\mathrm{TransferRate}\;=\;\frac{A_{\mathrm{cross}}-A_{\mathrm{base}}}{A_{\mathrm{direct}}-A_{\mathrm{base}}}. (1)

3.3 Statistics and protocol

Contrasts are computed within group and then bootstrapped over the seven groups; “k/7k/7” counts groups whose difference has the sign of the mean (7/77/7 is p=0.016p=0.016 under a sign test). Group spread on identity is ±0.10\pm 0.100.170.17, so we decline to interpret identity differences below about 0.150.15 and say so at each such row rather than dropping the row. Every contrast was found on group g0; the other six groups were rendered, trained and evaluated afterwards with the contrast list already fixed, and are reported as a held-out confirmation set. All four load-bearing contrasts replicate at 6/66/6 and both contrasts we retract fail there too, but five of six effects are smaller out of sample, by up to 2.4×2.4\times. Where a magnitude carries an argument we therefore quote the confirmation column; the full protocol and per-contrast table are in Appendix A.

4 The cross-task channel

This section measures the channel itself. Each direction is injected at a matched budget of 480 steps and the other direction is scored, which answers two questions in turn: how much of the directly trainable competence crosses (Eq. 1), and of what kind that competence is. The second answer constrains the first: the two directions turn out to move different things.

4.1 Rate and kind of transfer

Injecting through one direction and measuring the other gives, over 56 concepts, TransferRate 0.360.36 [0.23, 0.49] for G\rightarrowU and 0.540.54 [0.41, 0.67] for U\rightarrowG (Table 1). The difference is +0.17+0.17 [-0.05, +0.40], computed on unrounded group means, at five of seven groups, an unresolved null, so we claim no asymmetry in rate.

Table 1: Cross-task transfer, 56 concepts in seven groups, 480 steps in both directions. Both columns are accuracy (\uparrow); brackets are bootstraps over all 56 concepts and ±\pm is the standard deviation of the seven group means, the run-level spread a concept bootstrap cannot see. Blocks from top to bottom: the base model; generative injection and its substrate variant; understanding injection and its substrate variants; the mid-stack anchoring objective alone (§5.1) at two depths; and the combination of the two recipes.
condition und. name matching \uparrow gen. identity \uparrow
base model 0.243 [0.19, 0.31] ±\pm0.058 0.039 [0.02, 0.06] ±\pm0.032
G-inject (flow matching), shared+private 0.520 [0.44, 0.60] ±\pm0.121 0.653 [0.56, 0.75] ±\pm0.125
G-inject, shared MLP only 0.620 [0.53, 0.70] ±\pm0.119 0.717 [0.62, 0.81] ±\pm0.122
U-inject (LM CE), shared+private 0.989 [0.98, 1.00] ±\pm0.014 0.360 [0.27, 0.46] ±\pm0.105
U-inject, shared attention only 0.984 [0.97, 0.99] ±\pm0.013 0.078 [0.04, 0.13] ±\pm0.069
U-inject, shared MLP only 0.991 [0.98, 1.00] ±\pm0.013 0.339 [0.25, 0.44] ±\pm0.165
anchoring @ layer 14, alone 0.898 [0.84, 0.94] ±\pm0.024 0.808 [0.72, 0.89] ±\pm0.105
anchoring @ final norm, alone 0.332 [0.26, 0.41] ±\pm0.055 0.103 [0.06, 0.16] ±\pm0.056
G-inject + anchoring @ layer 14 0.946 [0.90, 0.98] ±\pm0.051 0.907 [0.85, 0.96] ±\pm0.042

The asymmetry that is demonstrable is qualitative. Scored with the candidate names removed from the context window, the conditions split perfectly along the training objective (Table 2): everything that ever computed a language-model cross-entropy produces the name, and nothing else does, however high its 4-way score. A condition can move 4-way matching from 0.2540.254 to 0.9000.900 and sit at chance on producing the same name.

Table 2: Matching the name against producing it, for seven conditions spanning both training objectives. All columns are accuracy (\uparrow); chance is 0.2500.250 for the 4-way probes and 0.1250.125 for the context-free ones. The last column, first sub-word, is the pre-specified arbiter, immune by construction to the shortcut the probe detects. Rows are grouped by whether the recipe ever computed a language-model cross-entropy.
condition LM-CE 4-way reverse 4-way context-free first sub-word
U-inject (LM cross-entropy) 1.000 1.000 0.938 0.922
U-inject, shared attention only 1.000 0.900 0.297 0.688
base model 0.254 0.242 0.141 0.125
G-inject (flow matching) 0.600 0.650 0.141 0.125
anchoring @ layer 14, alone 0.887 1.000 0.125 0.094
activation patch @ layer 3 0.887 1.000 0.234 0.125
activation patch @ layer 7 0.900 1.000 0.266 0.125

Three consequences follow. First, the G\rightarrowU result is transfer of matching competence. G-inject lifts 4-way matching from the base model’s 0.2540.254 to 0.6000.600, and that gain is real and learned, since a name-shuffle control stays at the base level and the binding is name-specific (Appendix I); but the same condition scores 0.1410.141 on the context-free probe, exactly the base model’s value, and 0.1250.125 on the first sub-word, exact chance. It is choosing the name, not saying it, and every G\rightarrowU number here should be read that way. Second, the directions differ in kind. U-inject, the stronger of the two conditions in Table 2 that computed a language-model cross-entropy, produces the name at 0.9380.938 context-free; the strongest of the others reach 0.8870.8870.9000.900 on 4-way matching yet 0.1250.1250.2660.266 context-free, so what is an unresolved null in rate is decisive in kind. Third, the limitation is not specific to our probes: an intervention that touches representations can move a 4-way score from 0.2540.254 to 0.9000.900 while teaching the model nothing it can use without candidates in the prompt, and most multiple-choice VLM evaluations share this vulnerability.

4.2 Carrier substrate and shared capacity

If shared computation is the operative variable, then which shared computation carries the binding should matter, and it does. Restricting U-inject to the shared expert’s attention projections saturates its own task (0.9840.984 name matching) and exports essentially nothing (0.0780.078 identity); the same budget in the shared expert’s MLP exports 0.3390.339. Paired within group the carrier advantage is +0.261+0.261 [+0.16, +0.38] with 7/77/7 groups agreeing, and +0.219+0.219 [+0.14, +0.31] on the confirmation set alone. Table 2 says why: attention-only injection reaches 0.6880.688 on first-sub-word production but only 0.2970.297 on the full context-free probe, the signature of a binding satisfiable by attending from the image to the name, a route the context-free text pass never runs. Attention learns an image\rightarrowtext shortcut; the MLP writes something the other pathway can read on its own, which is the same locus factual-editing work identifies in language models (Meng et al., 2022; Meng et al., 2023).

How much shared capacity export needs is a separate question, and the answer is more than the trained task needs. Holding the adapter budget fixed at 80.74M parameters and sliding it between the two experts, transfer falls monotonically as budget moves to the private expert, at Spearman 0.90-0.90 for G-inject and 1.00-1.00 for U-inject. The U-inject rows isolate the point: the direct task is saturated, exactly 1.0001.000 matching at all four allocations with shared rank above zero, while transfer falls by more than half, 0.5310.2420.531\rightarrow 0.242, as the shared rank drops from 32 to 8. At rank 8 the model names the concept flawlessly and has lost more than half its ability to draw it. A matched-rank control designed to detect siloing found none, moving cross-task accuracy by 0.01-0.01 on average, and on this model the private expert alone cannot hold a concept, so every binding that transfers here is carried by shared weights (Appendix D).

Where a binding is written therefore matters along two axes already: which substrate, and how much of it is shared. The rest of the paper varies the third and most consequential one: depth.

5 The entry-point window

§4.2 established that a binding transfers only if it is written into the computation the other task runs, and into the right substrate of it. Those are coarse coordinates, saying which weights may change, not where along the stack the concept enters the other task’s forward pass. This section varies that remaining coordinate, depth, while holding the objective fixed, and finds it is the decisive one. Table 3 collects every entry point measured in the paper on a single axis. The section proceeds in two steps: a probe that predicts export and an intervention showing the probe is not the cause (§5.1), then the depth sweep itself, in two media (§5.2).

Table 3: The entry points this paper compares, placed on one depth axis; the depth sweep behind the middle two blocks is finer than the rows shown and is given in full in Table 4. Each row puts the same binding at a different point of the shared computation; blocks are ordered by intervention medium, and by depth within each. Export is accuracy on the task direction that received no gradient (§3.2); the last column points to where each row is measured.
entry point shared computation after it exports §
input embeddings all 28 blocks, but nothing to route yet 5.2
activation edit, layer 3 25 blocks partial (0.53) 5.2
activation edit, layer 7 21 blocks ✓ (0.58) 5.2
activation edit, layer 14 14 blocks ✗ (0.04, at base) 5.2
weight edit, layer 3 25 blocks partial (0.60) 5.2
weight edit, layers 10–14 14–18 blocks ✓ (0.80) 5.2
weight edit, layers 21–26 2–7 blocks fading (0.35\to0.20) 5.2
weight edit, final norm none 5.2
adapter, shared attention only all, but satisfiable by a shortcut ✗ (0.078) 4.2
adapter, shared MLP only all ✓ (0.339) 4.2
adapter, private generation expert none the other pass executes 4.2

5.1 Alignment as a predictor of export

Semantic-address retrieval (SAR). For each concept k{1,,K}k\in\{1,\dots,K\}, its visual address akda_{k}\in\mathbb{R}^{d} is the shared expert’s hidden state at a fixed mid-stack layer when the understanding pathway encodes that concept’s images, mean-pooled over image tokens and images; its name state hkdh_{k}\in\mathbb{R}^{d} is the same pooling over the name’s sub-word tokens in context-free text. Center both sides across concepts, a~k=ak1Kjaj\tilde{a}_{k}=a_{k}-\tfrac{1}{K}\sum_{j}a_{j} and h~k\tilde{h}_{k} likewise, and let rkr_{k} be the rank of the concept’s own address among all KK when they are sorted by cos(h~k,a~j)\cos(\tilde{h}_{k},\tilde{a}_{j}). Then SAR=1Kk=1K1rk,\mathrm{SAR}\;=\;\frac{1}{K}\sum_{k=1}^{K}\frac{1}{r_{k}}, the mean reciprocal rank of name\rightarrowaddress retrieval: 1.01.0 exactly when every name retrieves its own concept’s address first.

SAR as a predictor.

Across 36 distinct configurations spanning injection side, adapter placement, constant-budget capacity split, substrate and data size, SAR correlates with export at Spearman ρ=+0.68\rho=+0.68, family-clustered bootstrap [+0.37,+0.88][+0.37,+0.88]. The relationship holds inside all four configuration families and no single family carries it. We deliberately quote no pp-value, as the points are not independent systems. Four are duplicate configurations; the rest come from four sweeps sharing concepts, model, data, and code path, and every point is one model on one concept group, so a pp-value would not answer anything about unified models. What the clustering does cost is precision: a fit that has never seen a family predicts its members’ export to within 0.120.120.200.20 in accuracy units, which supports ranking configurations and not point prediction.

The anchoring objective as an intervention on SAR.

The direct test of the predictor is to optimize it. Semantic Anchoring turns the retrieval criterion into a training objective: with the addresses aka_{k} frozen, the name states hkh_{k} are trained under the KK-way InfoNCE loss

anchor=1Kk=1Klogexp(cos(h~k,a~k)/τ)j=1Kexp(cos(h~k,a~j)/τ),τ=0.07,\mathcal{L}_{\mathrm{anchor}}\;=\;-\frac{1}{K}\sum_{k=1}^{K}\log\frac{\exp\!\left(\cos(\tilde{h}_{k},\tilde{a}_{k})/\tau\right)}{\sum_{j=1}^{K}\exp\!\left(\cos(\tilde{h}_{k},\tilde{a}_{j})/\tau\right)},\qquad\tau=0.07, (2)

which pulls each name’s state onto its own concept’s address and pushes it from the other K1K-1. The layer at which hkh_{k} is read is the objective’s one free choice, and it is the variable under test. Applied at the readout, after the final norm, of an understanding-side injection on one group, the objective drives that run’s SAR from 0.5830.583 to a perfect 1.0001.000 and moves its export from 0.5620.562 to 0.4920.492, a change of 0.07-0.07: perfect alignment, zero transfer (Figure 3). Read the other way, the observational fit says +0.10+0.10 of SAR accompanies +0.26+0.26 of export, and the intervention buys +0.42+0.42 of SAR and none of it. SAR also reads 1.0001.000 on a model that learned nothing else. What the readout intervention lacks is not alignment but position.

Figure 3: SAR against export across 36 configurations, and the intervention on SAR (arrow): anchoring applied at the readout moves the probe to a perfect 1.0001.000 and leaves export where it was. A quantity can order configurations well and still not be the thing to change.

The two media of the depth sweep.

If position is what the readout intervention lacked, moving the entry point should recover transfer with everything else held fixed. The rest of the section therefore sweeps the depth at which Eq. 2 is applied, in two media that differ in what they may change. In the weight medium, LoRA adapters are trained against the objective read at layer \ell, for 480 steps. In the activation medium no weight changes at all: the objective’s alignment term is maximized in closed form on the residual stream itself. Freeze every weight and add one dd-vector per concept to the residual stream at a single site, at the token positions where that concept’s name appears; positions are recovered at layer 0 by matching the exact sub-word embedding sequence, so training and evaluation locate them identically. The alignment term of that objective admits a minimal analytic edit: keep the name state’s own mean and deviation norm, and rotate only the deviation direction onto the image address. The analytic edit exists because a weight-based comparison alone would confound the site with the optimization, a deeper site might simply be harder to train, and an edit with no gradient step removes that confound: it puts the alignment probe within 0.01230.0123 of ceiling on average at every depth by construction, and never further than 0.29050.2905 against a chance loss of 2.07942.0794, so the sweep measures capability rather than optimization, at a cost of 8×3584=28.78\times 3584=28.7K cached values per group and no gradient steps. The naive alternative, setting the name’s state to the image address, also imports the modality offset and the magnitude, and produces an edit large enough to destabilize the forward pass. Appendix C derives the solution and gives the two places where it is not exact.

5.2 The depth window in activations and in weights

Figure 4: Export against entry-point depth, for the same anchoring objective at the same site, differing only in whether activations (blue) or weights (purple) may change. Left is export on the axis that cannot be gamed; bands are group-level bootstraps over all seven groups. The orange curve adds a flow-matching gradient and is one group, drawn dashed. Both anchor-only media give a window, and the weight medium’s reaches deeper.
Table 4: The depth sweep at 56 concepts, in both media and under two identity encoders. Identity is accuracy (\uparrow); the bootstrap is over the seven groups and the “vs. norm” column is paired within group, with k/7k/7 counting groups agreeing in sign. The CLIP column scores the same generated images under a second vision tower. All twelve sites of the activation sweep are listed; the weight arm was run at the nine sites where it has entries, and a dash means the site was not measured in that medium. The base model scores 0.0390.039 on identity and 0.2430.243 on matching.
activations, anchor only (0 gradient steps) weights, anchor only (480 steps)
entry point identity (DINOv2) (CLIP) sd vs. norm identity vs. norm
layer 0 0.323 [0.22, 0.42] 0.269 0.145 +0.283+0.283 7/7
layer 3 0.528 [0.33, 0.72] 0.433 0.297 +0.489+0.489 6/7 0.602 [0.47, 0.75] +0.499+0.499 7/7
layer 7 0.584 [0.46, 0.72] 0.512 0.196 +0.545+0.545 7/7 0.769 [0.69, 0.84] +0.666+0.666 7/7
layer 10 0.366 [0.28, 0.45] 0.281 0.127 +0.327+0.327 7/7 0.800 [0.70, 0.89] +0.698+0.698 7/7
layer 14 0.040 [0.02, 0.07] 0.054 0.036 +0.001+0.001   3/7 0.808 [0.73, 0.88] +0.705+0.705 7/7
layer 17 0.047 [0.02, 0.08] 0.051 0.040 +0.008+0.008   5/7
layer 21 0.033 [0.01, 0.06] 0.048 0.032 0.006-0.006   2/7 0.352 [0.25, 0.47] +0.249+0.249 7/7
layer 24 0.038 [0.02, 0.06] 0.056 0.029 0.001-0.001   2/7 0.271 [0.19, 0.36] +0.169+0.169 6/7
layer 25 0.040 [0.02, 0.06] 0.051 0.030 +0.001+0.001   2/7
layer 26 0.037 [0.02, 0.06] 0.056 0.031 0.002-0.002   1/7 0.202 [0.15, 0.26] +0.099+0.099 6/7
layer 27 0.039 [0.02, 0.07] 0.051 0.035 +0.000+0.000   0/7 0.115 [0.05, 0.18] +0.012+0.012   3/7
after the norm 0.039 [0.02, 0.07] 0.051 0.035 0.103 [0.06, 0.14]

Peak and extent of each medium’s window.

Entering mid-stack beats entering at the readout by +0.705+0.705 [+0.61, +0.79] for weights and +0.545+0.545 [+0.40, +0.70] for activations, 7/77/7 groups in both cases. The activation window rises to a peak of 0.5840.584 at layer 7 and from layer 14 onward is indistinguishable from the base model at the resolution of this experiment: every site falls within ±0.008\pm 0.008 of the final-norm baseline, with at most 5/75/7 groups agreeing in sign (Table 4). The weight window peaks later, at layers 10–14 with 0.8000.800 and 0.8080.808, and then declines steadily to 0.1150.115 at layer 27. So changing what a site computes roughly doubles the usable depth relative to adding a fixed offset to what it outputs. It does not remove the depth dependence, and the activation arm’s descent is steep rather than discontinuous: the transition falls between the probed layers 10 and 14, and the one group where layer 12 was also measured reads 0.1640.164 there, between 0.4690.469 at layer 10 and 0.0160.016 at layer 14.

Layer 0 and the input embeddings.

At layer 0 the activation arm gives 0.3230.323 [0.22, 0.42] against 0.5840.584 at layer 7, and at the input embeddings it sits at the base model’s level (0.0230.023, one group). An edit therefore needs enough computation before it as well as after: at those sites the state being edited is still essentially the token itself, and overwriting its discriminative direction with an image-derived one places it in a region of state space the downstream network does not read. Layer 0 is nonetheless well above the norm (+0.283+0.283, 7/77/7), so the shallow end is a graded rise and not a second cliff. The weight arm is less affected, reaching 0.6020.602 already at layer 3, because it changes a function rather than overwriting a state.

Identity under a second image encoder.

Identity is a 24-way retrieval hit rate and so inherits DINOv2’s notion of sameness. The two identity columns of Table 4 differ in nothing but the encoder, and scoring the same generations under CLIP’s vision tower (Radford et al., 2021) gives the same curve: Pearson r=0.997r=0.997 across the twelve sites, the same peak site, a mean absolute difference of 0.0340.034, and the same sign and k/7k/7 verdict at every site. CLIP reads about 0.060.06 lower inside the window and 0.0150.015 higher at the base level, which narrows the measured window slightly and moves nothing about where it is.

Identity rather than 4-way matching as the sweep’s metric.

Across this sweep 4-way matching stays at 0.840.840.900.90 from layer 0 to layer 10 while identity traverses its entire range beneath it, and Table 2 settles the interpretation: every activation patch is at chance on producing the name, so the patch installs drawability and not both modalities. Figure 4 shows a second hazard. Adding a flow-matching gradient flat-lines the curve at 0.950.950.990.99 from layer 3 to layer 26, because a generative objective produces identity wherever the anchor sits. A task loss can therefore mask depth dependence entirely, a caution for any alignment-depth ablation that also trains the task.

Placebo, magnitude, and dose controls.

Three controls rule out the obvious alternatives directly (Table 17, Appendix I). The derangement placebo gives each concept another concept’s address at identical magnitude, 250.7250.7 against 250.4250.4 at layer 3, and identical direction statistics, with only the pairing wrong; identity goes to 0.0000.000, below the base model’s 0.0360.036, because the edited names now retrieve the wrong concept’s images rather than no concept at all. The effect is not a magnitude artifact, since δ/state\lVert\delta\rVert/\lVert\text{state}\rVert stays in 0.370.370.440.44 from layer 3 to layer 27 while the residual norm grows sixteenfold. And a quarter-magnitude edit degrades gracefully at a working site and stays unresponsive at a site that shows no effect, so deep sites are not merely over-perturbing.

Depth therefore gates usability on this model, in both media and under both encoders. Whether it gates usability on any model is the next question, and the answer turns out to require a second condition (§6.2).

6 The semantic-format requirement

6.1 The activation edit on four architectures

The closed-form patch ports without a training stack, which is what makes replication cheap: read the address from the understanding pathway at layer LL, read the name’s state at the same layer, rotate, inject, generate, with every weight frozen. We ported it to three further models chosen to span backbone family, scale and generation mechanism: Janus-Pro-1B (Chen et al., 2025), autoregressive over discrete tokens; Lumina-DiMOO-8B (Xin et al., 2025), discrete diffusion; and Omni-Diffusion-7B (Li et al., 2026a), masked discrete diffusion. Each model is swept over its whole stack with 12 concepts against a 12-way bank. Base levels are measured by running the identical code path at α=0\alpha=0, not assumed to be the chance line: Omni-Diffusion’s base model scores 0.2500.250 against a 0.0830.083 chance line. Janus was never used to develop the method and each later model was chosen before its curve was seen; per-model injection modules and probed depths are in Appendix G. The result divides the three: the window reappears on Janus-Pro, while neither Lumina-DiMOO nor Omni-Diffusion shows an effect at any depth (Table 5, Figure 5).

Figure 5: The same activation edit on four models, against relative depth so stacks of 24, 28 and 32 blocks are comparable. Curves are grouped by what the understanding pathway encodes: solid for a semantic vision encoder, dashed for a reconstruction codebook. Left is raw identity with each model’s own measured base level as a faint dotted line; right subtracts that level, the only quantity comparable across models whose base levels differ sevenfold. The shaded band is the shallow third, where both semantic-encoder models sit above their base models and the other two never leave theirs.
Table 5: Peak and base identity for each of the four models, accuracy (\uparrow). Visual peak is the best site on the whole depth sweep and base is the unmodified model measured on the same generations. The word column rotates the pseudo-name onto a real word’s state through the identical code path and is the instrument check (§6.1). Grouping is by what the understanding pathway encodes.
model understanding representation base visual peak word verdict
BAGEL-7B-MoT ViT, semantic 0.036 0.584 window
Janus-Pro-1B SigLIP, semantic 0.052 0.583 0.625 window
Lumina-DiMOO-8B VQ codebook 0.104 0.167 0.656 null, instr. works
Omni-Diffusion-7B MagViT-v2 VQ 0.250 0.250 0.500 null, instr. works

Replication on Janus-Pro.

The window is not an artifact of one model. Janus-Pro shares none of BAGEL’s backbone, scale, encoder coupling or generation mechanism, and it reproduces the shape. The curve rises out of the embeddings and peaks at relative depth 0.120.12 with 0.5830.583, against its own LoRA-trained ceiling of 0.6250.625. By half depth it is extinguished (0.1350.135 at rel. 0.540.54 against a base level of 0.0520.052; Table 14). An intervention with no gradient steps therefore recovers 93%93\% of what training recovers, against 80%80\% on BAGEL. What replicates is that a window exists, opens shallow and closes by half depth; where it peaks does not, since BAGEL is maximized at rel. 0.290.29 and Janus at rel. 0.120.12.

Analysis of the two models with no entry-point effect.

The two null sweeps peak at 0.1670.167 against a base level of 0.1040.104 and at 0.2500.250 against 0.2500.250. On its own neither is yet a finding about the model, because a patch that fires and does nothing is indistinguishable from a faulty port. Three checks separate the two readings. The patch is applied: every port counts its own applications, and both models re-run the whole stack at every denoising step, so the edit fires 32 times per image on Lumina-DiMOO and 260 times on Omni-Diffusion. It is not too weak to be detected: it already reaches 0.62×0.62\times and 0.51×0.51\times the state norm against 1.04×1.04\times on Janus, and raising it further only degrades the alignment it was meant to install, to centered cosine 0.7720.772 from 0.9930.993 on Lumina. The decisive check runs the same code path with the visual address replaced by a real word’s state at that layer, rotating brindolt onto “elephant”. It is calibrated on Janus, where the two targets are interchangeable (0.6250.625 word against 0.5830.583 visual). On Lumina-DiMOO and Omni-Diffusion it moves the model to 6.3×6.3\times and 2.0×2.0\times its base level, while the visual target leaves both at or below base (Table 15). Both nulls are therefore about the target rather than the method: the editing machinery works on all four models, and what these two cannot deliver is a visual address.

The four models split two against two, and the split follows what the understanding pathway encodes rather than anything the word “unified” names. §6.2 tests that reading against the alternatives.

6.2 Weight sharing versus representation format

Weight sharing.

“Unified” is a qualitative label, so we made the axis quantitative: for one real training batch per direction we record the set of parameters each direction uses and report the parameter-count-weighted Jaccard overlap. The estimator has to intersect a forward-hook trace with a gradient trace, since either alone is badly wrong. A hook trace counts modules that are computed and discarded, and a gradient trace counts empty-slice experts, which scores BAGEL at 0.9610.961 when the true figure is 0.5000.500 (Appendix F). Measured this way, the model that shares the least transfers the most: BAGEL shares 0.5000.500 of its backbone and reaches TransferRate 0.5390.539 on GUG\!\to\!U and 0.9240.924 on UGU\!\to\!G, while Janus-Pro shares 0.8730.873 and reaches 0.2910.291 and 0.4730.473. These four rates come from the cross-architecture protocol of 12 concepts against a 12-way bank, not from the 56-concept runs of Table 1, so they are comparable to each other and not to that table. More shared weight is plainly not sufficient for more transfer. We stop there rather than fitting a trend: two architectures that also differ in scale cannot separate sharing from anything else, and the split that does hold across all four models is the one below.

Representation format.

The grouping in Table 5 is not by backbone family, since BAGEL and Omni-Diffusion share a Qwen2.5-7B lineage and land on opposite sides, nor by scale, since Janus succeeds at 1.51.5B while Lumina-DiMOO fails at 88B. The two models where a visual address is usable read their understanding features from a semantic vision encoder; the two where it is not derive them from a reconstruction objective over a VQ codebook. Lumina-DiMOO is the most diagnostic case: images and text occupy one vocabulary and one embedding table, the edit demonstrably lands at centered cosine 0.9930.993, its derangement placebo sits at 0.0940.094, and the address is still unusable, because a VQ index encodes which codebook entry reproduces a patch and not which object is depicted. Entry point is therefore necessary and not sufficient. The two directions must also represent concepts in a common semantic format at that depth, which unified weights do not supply and a semantic understanding encoder does.

7 A low-cost method for generating images of new concepts

The entry-point rule earns its keep if it improves how concepts are injected in practice. §5.2 says a binding is usable by both directions when it enters the shared computation mid-stack, and §5.1 supplies an objective, Eq. 2, that writes a binding at any chosen depth without touching either task’s loss. Taken together they prescribe a recipe: apply the anchoring objective at the mid-stack peak and nowhere else, and skip the generative gradient entirely. This section evaluates that recipe, and prices every alternative on what it costs the model’s general ability.

Refer to caption
Figure 6: Mid-stack Semantic Anchoring. (a) Once, before training, each concept’s images are embedded through the frozen understanding pathway and the shared expert’s states are mean-pooled at layer 14 into a frozen visual address aka_{k}. (b) At each step, a short prompt containing the name runs to the same layer, the name’s sub-word states are pooled into hkh_{k}, and a KK-way InfoNCE pulls hkh_{k} onto aka_{k} and away from the other concepts’ addresses. No flow-matching gradient is ever computed, which is where the generative route’s 41%41\% GenEval cost originates (Table 6); anchoring costs 0.1%0.1\% and acquires the concept for both directions (Table 1).

Mid-stack Semantic Anchoring.

The recipe instantiates Eq. 2 at layer L=14L=14 (Figure 6). Before training, embed M=8M=8 images of each concept through the model’s own understanding pathway and mean-pool the shared expert’s hidden states at layer LL; freeze those KK addresses aka_{k}. At each step, run KK short prompts “template {name}” (\approx80 tokens in total), pool over each name’s own sub-word tokens at the same layer to get hkh_{k}, and take one step on the anchoring loss. The template is resampled each step. The recipe uses no supervision either task lacks, the same images and the same names, and it adds no module or token beyond the LoRA adapter every baseline here also trains. One \approx80-token forward and backward per step is its whole cost. It computes no generative gradient, which turns out to be the source of the damage.

Concept acquisition without a flow-matching gradient.

Run the anchor alone for 480 steps with the flow-matching objective switched off: over 56 concepts the model reaches 0.8980.898 [0.84, 0.94] name matching and 0.8080.808 [0.72, 0.89] identity, against 0.5200.520 and 0.6530.653 for a flow-matching baseline at comparable wall-clock (Table 1). Paired within group, the matching advantage is +0.379+0.379 [+0.29, +0.47] with 7/77/7 agreeing; the identity advantage is +0.155+0.155 [+0.00, +0.29] with 6/76/7 and a lower bound on zero. Anchoring alone is far better on the task it was never given, and level on the task the flow-matching objective exists to serve.

Table 6: General text-to-image ability retained after each recipe. GenEval (Ghosh et al., 2023) prompts, all 553, two images each, identical seeds, all columns accuracy (\uparrow). We substitute an OWLv2 detector (Minderer et al., 2023) for the official Mask2Former, so absolute scores are not comparable to published GenEval numbers and every claim here is a Δ\Delta against the same base model under the same detector. Steps counts the optimizer steps the recipe takes, and flow steps how many of them compute a flow-matching gradient.
condition steps flow steps overall Δ\Delta rel. identity
base (unmodified) 0.681 0.036
activation patch @ layer 3 0 0 0.681 0.0000.000 0.0%0.0\% 0.930
anchoring @ layer 14, alone 480 0 0.680 0.001-0.001 0.1%0.1\% 0.930
U-side, shared MLP only 1600 0 0.680 0.001-0.001 0.1%0.1\% 0.445
U-side then a generation phase 1760 160 0.680 0.001-0.001 0.1%0.1\% 0.891
anchoring @ layer 14 ++ flow matching 480 480 0.638 0.042-0.042 6.2%6.2\% 0.953
joint gen++und 640 640 0.692 +0.011+0.011 1.6%-1.6\% 0.820
generative default 960 960 0.401 0.279-0.279 41.0%41.0\% 0.922

Attribution of the GenEval loss.

Table 6 quantifies the cost of each recipe on 553 held-out prompts containing no pseudo-name. Cost and benefit come from the same runs, so its last column is measured on the same group of eight as its damage columns. The two routes are priced where they acquire the concept equally well, identity 0.9300.930 against 0.9220.922, rather than at equal steps, which 480 steps of flow matching do not reach (0.4690.469). The standard generative route costs 28 points of the prompt suite, 41%41\% of the model’s measured general text-to-image ability. The loss is not diffuse: it concentrates in the compositional categories, two-object at 0.485-0.485 and spatial position at 0.370-0.370, while single-object prompts survive at 0.150-0.150. A model fine-tuned on eight isolated objects largely forgets how to put two things in one picture and where. Across the table every point of damage coincides with the presence of a flow-matching gradient: the two methods that never compute one cost 0.1%0.1\% each, and a 160-step generation phase costs 0.1%0.1\%, a 480-step phase 6.2%6.2\%, a 960-step phase 41%41\%. Anchoring alone also places the concept in unseen scenes at identity 0.9630.963 with CLIP-T 0.2300.230, above the base model’s 0.2220.222 where the generative route reaches 0.1910.191, so composition survives and not merely the aggregate score.

Identity against a same-category sibling.

A 24-way retrieval over single assets from distinct categories could in principle be won by drawing a generic member of the right category. Rebuilding three groups from same-category sibling pairs removes that shortcut, and every trained condition still tells its asset from its own sibling at 0.690.69 to 0.910.91 against the base model’s 0.4840.484. The residual shortcut lands exactly where the mechanism predicts: a sibling in the bank costs flow matching +0.182+0.182 [+0.09, +0.29] and the two address-aligning interventions +0.055+0.055 and +0.016+0.016, both intervals containing zero. A pixel-level target can be partly satisfied by a category-typical member; an address-alignment target cannot, because the address belongs to one asset. Appendix H gives the full study and the resulting correction to identity levels elsewhere, roughly 0.180.18 for flow matching and 0.050.05 for anchoring.

8 Discussion

Scope of the claim.

The defensible conclusion is that the usability of an injected concept binding depends strongly on where it enters downstream computation shared across tasks, and that the two transfer directions must represent concepts in a common semantic format at that point. Three observations support this view: the embedding layer leaves the greatest amount of downstream computation, yet injection there fails; attention-only injection traverses the entire network, yet does not transfer to the other task; and the effective entry-point windows differ in width between the two directions. Extending the common-semantic-format requirement to the training target suggests that the operative variable should be whether the generation target forces information through the shared semantic pathway.

Limitations.

Five aspects of the design bound what is claimed here, and each marks a concrete next experiment. (i) “Computation after the entry point” is operationalized as layer count, and the block-deletion experiment built to refine it separates the two accounts only in part, because deletion is not equally costly on the two sides of a site: two blocks immediately before the entry point cost fifteen times more general prompt fidelity than two immediately after, so at comparable damage both arms sit at the base level (Appendix E). (ii) The window is measured across four architectures, an observational series in which encoder type covaries with backbone, scale and generation mechanism, so training one architecture twice, once with a semantic and once with a reconstruction encoder, would turn the regularity into a controlled result. (iii) Identity is retrieval under two automatic encoders that agree closely with each other (r=0.997r=0.997 across the depth sweep) rather than under human judgement, which leaves the absolute levels open to calibration by a human study. (iv) BAGEL’s private generation expert is too weak to hold a concept on its own, so whether stronger private branches silo knowledge is untested. (v) Runs use eight concepts each by design, since concept count is task difficulty, which leaves open how the window behaves when a model is asked to hold hundreds of bindings at once.

Implications and future research.

These findings reframe concept learning in unified multimodal models as a problem of routing and representation, rather than solely one of parameter sharing or training scale. For model design, they suggest that new concepts should be introduced where understanding and generation still share both a compatible semantic format and sufficient downstream computation, which gives a principled basis for choosing adaptation sites instead of treating layers as interchangeable. For future research, the entry-point window offers a testable diagnostic for comparing architectures, objectives, and private-versus-shared pathways, while the semantic-format hypothesis motivates controlled studies that vary the generation target without changing the data. More broadly, identifying where knowledge becomes usable across tasks could guide more efficient multimodal adaptation, reduce unnecessary parameter updates, and distinguish models that merely store a concept from those that can deploy it across modalities and tasks.

9 Conclusion

In this paper, we asked whether a unified multimodal model can move a newly bound concept between understanding and generation, and separated that architectural question from the data question by binding a novel entity through exactly one direction and measuring the other. The channel is real both ways, but the directions differ in kind: generation training installs a name the model can match and not produce. What governs usability is where the binding enters. Alignment predicts export without causing it, while the same objective’s closed-form edit over activations works at layer 7 of 28 and is indistinguishable from the base model by layer 14, and carried by weights peaks at layers 10–14. Across four models the window appears only where the understanding pathway is a semantic vision encoder, so unified weights are not sufficient. Acting on that, we anchor a name onto the model’s own visual address at layer 14, with no generative gradient anywhere in the objective. This acquires 56 concepts at 0.8980.898 name matching and 0.8080.808 identity, for a 0.1%0.1\% relative loss of general text-to-image ability where the generative route costs 41%41\%. Entry point is a design variable that unified models already have and that their training recipes do not use. This paper leaves behind the means to use it: a contamination-free measurement of cross-task usability, an intervention that isolates depth from optimization by taking no gradient steps at all, and a condition on the host architecture that says where the variable takes effect.

References

  • Bi et al. (2026) Tianci Bi, Xiaoyi Zhang, Yan Lu, and Nanning Zheng. Vision foundation models can be good tokenizers for latent diffusion models. In IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. 43310–43319, 2026. arXiv:2510.18457.
  • Chameleon Team (2024) Chameleon Team. Chameleon: Mixed-modal early-fusion foundation models. arXiv preprint arXiv:2405.09818, 2024.
  • Chen et al. (2025) Xiaokang Chen, Zhiyu Wu, Xingchao Liu, Zizheng Pan, Wen Liu, Zhenda Xie, Xingkai Yu, and Chong Ruan. Janus-Pro: Unified multimodal understanding and generation with data and model scaling. arXiv preprint arXiv:2501.17811, 2025.
  • Chung et al. (2025) Jiwan Chung, Janghan Yoon, Junhyeong Park, Sangeyl Lee, Joowon Yang, Sooyeon Park, and Youngjae Yu. Are any-to-any models more consistent across modality transfers than specialists? In Annual Meeting of the Association for Computational Linguistics (ACL), pp. 2595–2606, 2025. arXiv:2505.24211.
  • Deitke et al. (2023) Matt Deitke, Dustin Schwenk, Jordi Salvador, Luca Weihs, Oscar Michel, Eli VanderBilt, Ludwig Schmidt, Kiana Ehsani, Aniruddha Kembhavi, and Ali Farhadi. Objaverse: A universe of annotated 3D objects. In IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. 13142–13153, 2023. arXiv:2212.08051.
  • Deng et al. (2025) Chaorui Deng, Deyao Zhu, Kunchang Li, Chenhui Gou, Feng Li, Zeyu Wang, Shu Zhong, Weihao Yu, Xiaonan Nie, Ziang Song, Guang Shi, and Haoqi Fan. Emerging properties in unified multimodal pretraining. arXiv preprint arXiv:2505.14683, 2025.
  • Gal et al. (2023) Rinon Gal, Yuval Alaluf, Yuval Atzmon, Or Patashnik, Amit H. Bermano, Gal Chechik, and Daniel Cohen-Or. An image is worth one word: Personalizing text-to-image generation using textual inversion. In International Conference on Learning Representations (ICLR), 2023. arXiv:2208.01618.
  • Ghosh et al. (2023) Dhruba Ghosh, Hannaneh Hajishirzi, and Ludwig Schmidt. GenEval: An object-focused framework for evaluating text-to-image alignment. In Advances in Neural Information Processing Systems (NeurIPS), pp. 52132–52152, 2023. arXiv:2310.11513.
  • Gupta et al. (2024) Akshat Gupta, Dev Sajnani, and Gopala Anumanchipalli. A unified framework for model editing. In Findings of the Association for Computational Linguistics: EMNLP 2024, pp. 15403–15418, 2024. arXiv:2403.14236.
  • Hu et al. (2022) Edward J. Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. LoRA: Low-rank adaptation of large language models. In International Conference on Learning Representations (ICLR), 2022. arXiv:2106.09685.
  • Jiao et al. (2025) Yang Jiao, Haibo Qiu, Zequn Jie, Shaoxiang Chen, Jingjing Chen, Lin Ma, and Yu-Gang Jiang. UniToken: Harmonizing multimodal understanding and generation through unified visual encoding. In IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR) Workshops, pp. 3639–3649, 2025. arXiv:2504.04423.
  • Li et al. (2024) Jiaqi Li, Miaozeng Du, Chuanyi Zhang, Yongrui Chen, Nan Hu, Guilin Qi, Haiyun Jiang, Siyuan Cheng, and Bozhong Tian. MIKE: A new benchmark for fine-grained multimodal entity knowledge editing. In Findings of the Association for Computational Linguistics: ACL 2024, pp. 5018–5029, 2024. arXiv:2402.14835.
  • Li et al. (2026a) Lijiang Li, Zuwei Long, Yunhang Shen, Heting Gao, Haoyu Cao, Xing Sun, Caifeng Shan, Ran He, and Chaoyou Fu. Omni-Diffusion: Unified multimodal understanding and generation with masked discrete diffusion. In International Conference on Machine Learning (ICML), 2026a. arXiv:2603.06577.
  • Li et al. (2026b) Zijie Li, Yichun Shi, Jingxiang Sun, Ye Wang, Yixuan Huang, Zhiyao Guo, Xiaochen Lian, Peihao Zhu, Yu Tian, Zhonghua Zhai, and Peng Wang. MMCORE: MultiModal COnnection with representation aligned latent embeddings. arXiv preprint arXiv:2604.19902, 2026b.
  • Liang et al. (2025) Weixin Liang, Lili Yu, Liang Luo, Srinivasan Iyer, Ning Dong, Chunting Zhou, Gargi Ghosh, Mike Lewis, Wen tau Yih, Luke Zettlemoyer, and Xi Victoria Lin. Mixture-of-Transformers: A sparse and scalable architecture for multi-modal foundation models. Transactions on Machine Learning Research (TMLR), 2025. arXiv:2411.04996.
  • Liu et al. (2023) Xingchao Liu, Chengyue Gong, and Qiang Liu. Flow straight and fast: Learning to generate and transfer data with rectified flow. In International Conference on Learning Representations (ICLR), 2023. arXiv:2209.03003.
  • Luo et al. (2026) Yinyi Luo, Wenwen Wang, Hayes Bai, Marios Savvides, and Jindong Wang. LatentUMM: Dual latent alignment for unified multimodal models. arXiv preprint arXiv:2605.17766, 2026.
  • Mao et al. (2025) Weijia Mao, Zhenheng Yang, and Mike Zheng Shou. UniRL: Self-improving unified multimodal models via supervised and reinforcement learning. arXiv preprint arXiv:2505.23380, 2025.
  • Meng et al. (2022) Kevin Meng, David Bau, Alex Andonian, and Yonatan Belinkov. Locating and editing factual associations in GPT. In Advances in Neural Information Processing Systems (NeurIPS), 2022. arXiv:2202.05262.
  • Meng et al. (2023) Kevin Meng, Arnab Sen Sharma, Alex Andonian, Yonatan Belinkov, and David Bau. Mass-editing memory in a transformer. In International Conference on Learning Representations (ICLR), 2023. arXiv:2210.07229.
  • Minderer et al. (2023) Matthias Minderer, Alexey Gritsenko, and Neil Houlsby. Scaling open-vocabulary object detection. In Advances in Neural Information Processing Systems (NeurIPS), 2023. arXiv:2306.09683.
  • Oquab et al. (2024) Maxime Oquab, Timothée Darcet, Théo Moutakanni, Huy Vo, Marc Szafraniec, Vasil Khalidov, Pierre Fernandez, Daniel Haziza, Francisco Massa, Alaaeldin El-Nouby, Mahmoud Assran, Nicolas Ballas, Wojciech Galuba, Russell Howes, Po-Yao Huang, Shang-Wen Li, Ishan Misra, Michael Rabbat, Vasu Sharma, Gabriel Synnaeve, Hu Xu, Hervé Jegou, Julien Mairal, Patrick Labatut, Armand Joulin, and Piotr Bojanowski. DINOv2: Learning robust visual features without supervision. Transactions on Machine Learning Research (TMLR), 2024. arXiv:2304.07193.
  • Page et al. (2026) John Page, Xuesong Niu, Kai Wu, and Kun Gai. Boosting latent diffusion models via disentangled representation alignment. arXiv preprint arXiv:2601.05823, 2026.
  • Qu et al. (2025) Leigang Qu, Haochuan Li, Wenjie Wang, Xiang Liu, Juncheng Li, Liqiang Nie, and Tat-Seng Chua. SILMM: Self-improving large multimodal models for compositional text-to-image generation. In IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. 18497–18508, 2025. arXiv:2412.05818.
  • Radford et al. (2021) Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, Gretchen Krueger, and Ilya Sutskever. Learning transferable visual models from natural language supervision. In International Conference on Machine Learning (ICML), pp. 8748–8763, 2021. arXiv:2103.00020.
  • Ruiz et al. (2023) Nataniel Ruiz, Yuanzhen Li, Varun Jampani, Yael Pritch, Michael Rubinstein, and Kfir Aberman. DreamBooth: Fine tuning text-to-image diffusion models for subject-driven generation. In IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. 22500–22510, 2023. arXiv:2208.12242.
  • Su et al. (2026) Zihan Su, Hongyang Wei, Kangrui Cen, Yong Wang, Guanhua Chen, Chun Yuan, and Xiangxiang Chu. Generation enhances understanding in unified multimodal models via multi-representation generation. In International Conference on Machine Learning (ICML), 2026. arXiv:2601.21406.
  • Tong et al. (2025) Shengbang Tong, David Fan, Jiachen Zhu, Yunyang Xiong, Xinlei Chen, Koustuv Sinha, Michael Rabbat, Yann LeCun, Saining Xie, and Zhuang Liu. MetaMorph: Multimodal understanding and generation via instruction tuning. In IEEE/CVF International Conference on Computer Vision (ICCV), pp. 17001–17012, 2025. arXiv:2412.14164.
  • Wang et al. (2026a) Chenlong Wang, Yuhang Chen, Zhihan Hu, Dongping Chen, Wenhu Chen, Sarah Wiegreffe, and Tianyi Zhou. Quantifying the gap between understanding and generation within unified multimodal models. arXiv preprint arXiv:2602.02140, 2026a.
  • Wang et al. (2026b) Weixing Wang, Liudvikas Zekas, Anton Hackl, Constantin Alexander Auga, Parisa Shahabinejad, Jona Otholt, Antonio Rueda-Toicen, and Gerard de Melo. Beyond accuracy: Benchmarking cross-task consistency in unified multimodal models. arXiv preprint arXiv:2604.25072, 2026b.
  • Wang et al. (2024) Xinlong Wang, Xiaosong Zhang, Zhengxiong Luo, Quan Sun, Yufeng Cui, Jinsheng Wang, Fan Zhang, Yueze Wang, Zhen Li, Qiying Yu, Yingli Zhao, Yulong Ao, Xuebin Min, Tao Li, Boya Wu, Bo Zhao, Bowen Zhang, Liangdong Wang, Guang Liu, Zheqi He, Xi Yang, Jingjing Liu, Yonghua Lin, Tiejun Huang, and Zhongyuan Wang. Emu3: Next-token prediction is all you need. arXiv preprint arXiv:2409.18869, 2024.
  • Wu et al. (2025a) Chengyue Wu, Xiaokang Chen, Zhiyu Wu, Yiyang Ma, Xingchao Liu, Zizheng Pan, Wen Liu, Zhenda Xie, Xingkai Yu, Chong Ruan, and Ping Luo. Janus: Decoupling visual encoding for unified multimodal understanding and generation. In IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. 12966–12977, 2025a. arXiv:2410.13848.
  • Wu et al. (2026) Junfeng Wu, Yi Jiang, Chuofan Ma, Yuliang Liu, Hengshuang Zhao, Zehuan Yuan, Song Bai, and Xiang Bai. Liquid: Language models are scalable and unified multi-modal generators. International Journal of Computer Vision (IJCV), 2026. arXiv:2412.04332.
  • Wu et al. (2025b) Size Wu, Wenwei Zhang, Lumin Xu, Sheng Jin, Zhonghua Wu, Qingyi Tao, Wentao Liu, Wei Li, and Chen Change Loy. Harmonizing visual representations for unified multimodal understanding and generation. In IEEE/CVF International Conference on Computer Vision (ICCV), pp. 17739–17750, 2025b. arXiv:2503.21979.
  • Xie et al. (2026) Ji Xie, Trevor Darrell, Luke Zettlemoyer, and XuDong Wang. Reconstruction alignment improves unified multimodal models. In International Conference on Learning Representations (ICLR), 2026. arXiv:2509.07295.
  • Xie et al. (2025a) Jinheng Xie, Weijia Mao, Zechen Bai, David Junhao Zhang, Weihao Wang, Kevin Qinghong Lin, Yuchao Gu, Zhijie Chen, Zhenheng Yang, and Mike Zheng Shou. Show-o: One single transformer to unify multimodal understanding and generation. In International Conference on Learning Representations (ICLR), 2025a. arXiv:2408.12528.
  • Xie et al. (2025b) Jinheng Xie, Zhenheng Yang, and Mike Zheng Shou. Show-o2: Improved native unified multimodal models. In Advances in Neural Information Processing Systems (NeurIPS), 2025b. arXiv:2506.15564.
  • Xin et al. (2025) Yi Xin, Qi Qin, Siqi Luo, Kaiwen Zhu, Juncheng Yan, Yan Tai, Jiayi Lei, Yuewen Cao, et al. Lumina-DiMOO: An omni diffusion large language model for multi-modal generation and understanding. arXiv preprint arXiv:2510.06308, 2025.
  • Yu et al. (2025) Sihyun Yu, Sangkyung Kwak, Huiwon Jang, Jongheon Jeong, Jonathan Huang, Jinwoo Shin, and Saining Xie. Representation alignment for generation: Training diffusion transformers is easier than you think. In International Conference on Learning Representations (ICLR), 2025. arXiv:2410.06940.
  • Zhang et al. (2024) Xiang Zhang, Senyu Li, Ning Shi, Bradley Hauer, Zijun Wu, Grzegorz Kondrak, Muhammad Abdul-Mageed, and Laks V. S. Lakshmanan. Cross-modal consistency in multimodal large language models. arXiv preprint arXiv:2411.09273, 2024.
  • Zhao et al. (2025) Shanshan Zhao, Xinjie Zhang, Jintao Guo, Jiakui Hu, Lunhao Duan, Minghao Fu, Yong Xien Chng, Guo-Hua Wang, Qing-Guo Chen, Zhao Xu, Weihua Luo, and Kaifu Zhang. Unified multimodal understanding and generation models: Advances, challenges, and opportunities. arXiv preprint arXiv:2505.02567, 2025.
  • Zhong et al. (2026) Yu Zhong, Tianwei Lin, Ruike Zhu, Yuqian Yuan, Haoyu Zheng, Liang Liang, Wenqiao Zhang, Feifei Shao, Haoyuan Li, Wanggui He, Hao Jiang, and Yueting Zhuang. Unified personalized understanding, generating and editing. In IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. 29400–29409, 2026. arXiv:2601.06965.
  • Zhou et al. (2025) Chunting Zhou, Lili Yu, Arun Babu, Kushal Tirumala, Michihiro Yasunaga, Leonid Shamis, Jacob Kahn, Xuezhe Ma, Luke Zettlemoyer, and Omer Levy. Transfusion: Predict the next token and diffuse images with one multi-modal model. In International Conference on Learning Representations (ICLR), 2025. arXiv:2408.11039.

Appendix A Discovery and confirmation protocol

Every contrast in this paper was found on group g0. The other six groups were rendered, trained and evaluated afterwards against a fixed contrast list and are reported as a held-out confirmation set (Table 7). All four primary contrasts replicated across all six confirmation groups. We report both discovery and confirmation results, and where a magnitude carries an argument we use the confirmation column.

Table 7: Discovery versus confirmation. g0 is where each contrast was found; g1–g6 were run afterwards against a fixed list. The final column reports the discovery-to-confirmation ratio.
paired contrast discovery (g0) confirmation (g1–g6) pooled ratio
alignment @14 vs @ readout, identity +0.906+0.906 +0.672+0.672 [+0.59, +0.74] 6/6 +0.705+0.705 1.35×1.35\times
alignment @14 vs @ readout, matching +0.637+0.637 +0.554+0.554 [+0.50, +0.60] 6/6 +0.566+0.566 1.15×1.15\times
alignment alone vs G-inject, matching +0.362+0.362 +0.381+0.381 [+0.27, +0.49] 6/6 +0.379+0.379 0.95×0.95\times
shared MLP vs shared attention, export +0.516+0.516 +0.219+0.219 [+0.14, +0.31] 6/6 +0.261+0.261 2.36×2.36\times
alignment alone vs G-inject, identity +0.273+0.273 +0.135+0.135 [-0.04, +0.29] 5/6 +0.155+0.155 2.02×2.02\times
G-inject into shared MLP vs default +0.148+0.148 +0.049+0.049 [-0.06, +0.17] 2/6 +0.064+0.064 3.00×3.00\times

The SAR correlation, by family. After removing four duplicate configurations, Table 8 reports within-family correlations, correlations pooled over all remaining families, and leave-one-family-out MAE.

Table 8: SAR versus export with the dependence structure respected. ρ\rho within is the correlation inside one sweep; ρ\rho without is the pooled correlation with that sweep deleted; MAE is the error of predicting that sweep’s configurations from a fit that never saw them, in accuracy units.
configuration family nn ρ\rho within ρ\rho without MAE predicting it
capacity allocation 16 +0.46+0.46 +0.78+0.78 0.200
placement / main 10 +0.60+0.60 +0.59+0.59 0.137
recipe 6 +0.71+0.71 +0.67+0.67 0.194
substrate 4 +0.80+0.80 +0.66+0.66 0.122
pooled 36 +0.68\bm{+0.68}, family-clustered bootstrap [+0.37,+0.88][+0.37,+0.88]

Direct-task accuracy and SAR were evaluated for each configuration.

Appendix B Probe and evaluation details

The context-free production probe is scored, not sampled.

No text is generated and no decoding hyper-parameter exists to tune. For each held-out image and each candidate pseudo-name in the group we run one forward pass over the fixed string “\langleimage\rangle This is a {name}” and read the model’s log-probability of the name’s sub-word sequence; the prediction is the argmax over candidates. There is no temperature, no top-kk/top-pp, and no sampling seed, so the probe is deterministic given the image set.

We corrected unconditional name probability with pointwise mutual information and fixed first-sub-word-only scoring before running the evaluation. We also recorded full-name scores for all conditions in Table 2.

Figure 7: The same conditions scored with the candidate names in the prompt and with them removed, grouped by evaluation condition. The shaded region is production chance.

Figure 7 plots the same split.

Per-concept identity distribution. We computed identity per concept over 16 generations at layer 7. Of 56 concepts, 17 score 1.0001.000, 6 score 0.0000.000, and the remainder lie between; uncertainty is reported with the pre-specified group-level bootstrap.

Encoder agreement at site and concept levels. We computed agreement between the two encoders across twelve sites and across 56 individual concepts at layer 7. The site-level correlation is r=0.997r=0.997; the concept-level correlation is r=0.821r=0.821, with mean absolute difference 0.1650.165 and the same above-floor verdict on 46/5646/56.

Notation for the “shared++private” rows.

In the U-inject conditions the adapter is instantiated on both experts, but the understanding pass routes through the shared and understanding-side experts only, so the generation-side private expert receives no gradient and is bit-identical to its initialization at the end of training. The row label describes where parameters were placed, not where they were updated. At evaluation both branches are active in every condition and the routing is the model’s own; we never disable an expert at test time.

Appendix C The closed-form activation edit

This appendix specifies the objective, intervention, closed-form edit, evaluated variants, residual measurements, and stability protocol used for the activation arm.

The objective.

Fix a layer LL and a group of KK concepts. For concept kk, let vkDv_{k}\in\mathbb{R}^{D} be its visual address: the shared expert’s layer-LL hidden state mean-pooled over the image tokens of M=8M=8 understanding-side images, averaged over images. Let tkDt_{k}\in\mathbb{R}^{D} be its name state: the layer-LL hidden state of a short prompt ending in the pseudo-name, mean-pooled over that name’s own sub-word token positions. Write t¯=1Kjtj\bar{t}=\tfrac{1}{K}\sum_{j}t_{j} and tkc=tkt¯t_{k}^{c}=t_{k}-\bar{t}, and likewise vkcv_{k}^{c}. Semantic Anchoring minimizes the KK-way InfoNCE

=1Kk=1Klogexp(cos(tkc,vkc)/τ)j=1Kexp(cos(tkc,vjc)/τ),τ=0.07.\mathcal{L}\;=\;-\frac{1}{K}\sum_{k=1}^{K}\log\frac{\exp\!\big(\cos(t_{k}^{c},v_{k}^{c})/\tau\big)}{\sum_{j=1}^{K}\exp\!\big(\cos(t_{k}^{c},v_{j}^{c})/\tau\big)},\qquad\tau=0.07. (3)

Both sides are centered across the group before the cosine. That is the whole reason a closed form exists: centering removes the constant text-versus-image offset, so the objective constrains only the direction of each concept’s deviation from its group mean, and says nothing at all about the mean or about any deviation magnitude.

The intervention.

Freeze every weight. Introduce one vector δkD\delta_{k}\in\mathbb{R}^{D} per concept, added to the residual stream at layer LL at exactly the token positions where concept kk’s name appears, so the patched state is tk=tk+δkt_{k}^{\prime}=t_{k}+\delta_{k}. Positions are recovered at layer 0 by matching the name’s exact sub-word embedding sequence, so training and evaluation locate them identically and the intervention is self-contained.

The solution.

Hold the center fixed at t¯\bar{t} and set

δk=t¯+tkcvkcvkctktkt¯=tkcv^kc,\boxed{\;\delta_{k}\;=\;\bar{t}\;+\;\lVert t_{k}^{c}\rVert\cdot\frac{v_{k}^{c}}{\lVert v_{k}^{c}\rVert}\;-\;t_{k}\;}\qquad\Longrightarrow\qquad t_{k}^{\prime}-\bar{t}\;=\;\lVert t_{k}^{c}\rVert\,\hat{v}_{k}^{c}, (4)

which is parallel to vkcv_{k}^{c} and therefore attains cos=1\cos=1 on every diagonal term of Eq. 3 simultaneously. That is the global maximum of the alignment term, at every depth, with no gradient step. It is not in general the minimizer of Eq. 3 itself: the negative terms cos(tkc,vjc)\cos(t_{k}^{c^{\prime}},v_{j}^{c}) are then fixed at cos(vkc,vjc)\cos(v_{k}^{c},v_{j}^{c}) by the addresses themselves and are not driven down, and holding the center at the pre-patch t¯\bar{t} is a constraint rather than an identity, since the patched states’ own mean is t¯+1Kktkcv^kc\bar{t}+\tfrac{1}{K}\sum_{k}\lVert t_{k}^{c}\rVert\hat{v}_{k}^{c}, which need not equal t¯\bar{t}. Both approximations are what the residual measurements below quantify, and neither is assumed away. Two constraints are imposed deliberately and neither is required by the objective: the patched state keeps the group mean t¯\bar{t}, and it keeps its own deviation norm tkc\lVert t_{k}^{c}\rVert rather than the image’s. Only the direction rotates. Among all δk\delta_{k} achieving cos=1\cos=1 this is the unique minimizer of δk\lVert\delta_{k}\rVert subject to preserving both, which is what we mean by calling it minimal (Figure 8).

Figure 8: The edit in the centered space where the objective is evaluated. The reported experiments use the direction-only edit in panels (a)–(b); panel (c) shows the separately evaluated naive edit.

Evaluated edit variants. We evaluated both tk=vkt_{k}^{\prime}=v_{k} and the minimal edit of Eq. 4. All reported activation-arm results use the minimal edit. At layer 14 it has δ=640\lVert\delta\rVert=640 against a name-state norm of 16021602, a relative size of 0.400.40.

Residual measurements. We measured re-centring and template-averaging residuals for all 84 closed-form solves in the seven-group sweep. The post-patch anchoring loss is 0.0123 on average against chance log8=2.0794\log 8=2.0794 and reaches 0.2905 at its maximum; the corresponding worst-case reduction from chance toward zero is 86%.

The single-group table, including the flow-matching arm. Table 9 reports the original eight-concept measurement for anchoring-only activation edits, anchoring-only weight edits, and weight edits trained with anchoring plus flow matching. Seven-group levels are reported in Table 4.

Table 9: The depth sweep on one group of eight, three arms, accuracy (\uparrow). All optimize the same anchoring objective at the same site. The first two differ only in medium; the third adds flow matching. The base model scores 0.0360.036 on identity and 0.2540.254 on matching.
generation identity name matching
entry point activations weights weights activations weights weights
anchor only anchor only + flow anchor only anchor only + flow
layer 3 0.930 0.945 0.949 0.887 0.900 0.900
layer 7 0.828 0.914 0.984 0.900 0.925 0.950
layer 10 0.469 0.938 0.862 0.962
layer 14 0.016 0.930 0.984 0.500 0.887 0.921
layer 21 0.023 0.633 0.988 0.113 0.787 0.894
layer 24 0.023 0.406 0.965 0.138 0.775 0.919
layer 26 0.023 0.203 0.977 0.138 0.663 0.856
layer 27 0.016 0.055 0.625 0.138 0.350 0.662
after the norm 0.016 0.023 0.138 0.250

Composition and stability. We applied the edit at one site at a time. Across depths we measured δ/t=0.56\lVert\delta\rVert/\lVert t\rVert=0.56 at layer 0, 0.400.40 at layer 14, and 0.380.38 at layer 24; the magnitude sweep therefore reports this ratio and varies α\alpha.

Appendix D Capacity allocation

Holding the adapter budget fixed at 80.74M trainable parameters and sliding it between BAGEL’s two experts asks a question placement ablations cannot: not whether an adapter confined to the private expert can transfer, but what an objective free to use either does with a private store when one is available.

Table 10 reports the full constant-budget sweep.

Table 10: Constant-budget capacity allocation, group of eight, accuracy (\uparrow); the italicised all-private row is the measured base level of this sweep, 0.1380.138 for matching and 0.0160.016 for retrieval, and is what the last column subtracts; analytic chance is 0.2500.250 and 0.0420.042. Trainable parameters are identical in every row. Export efficiency is (cross - base)/(direct - base), blank when the direct task is within 0.150.15 of that base.
direction rundr_{\text{und}} rgenr_{\text{gen}} private share direct cross export eff.
G-inject 32 0 0.00 0.773 0.575 0.58
G-inject 24 8 0.25 0.883 0.700 0.65
G-inject 16 16 0.50 0.781 0.525 0.51
G-inject 8 24 0.75 0.531 0.412 0.53
G-inject 0 32 1.00 0.102 0.138
U-inject 32 0 0.00 1.000 0.531 0.60
U-inject 24 8 0.25 1.000 0.445 0.50
U-inject 16 16 0.50 1.000 0.398 0.44
U-inject 8 24 0.75 1.000 0.242 0.26
U-inject 0 32 1.00 0.138 0.016
Figure 9: A fixed adapter budget slid between the shared and private experts. In the U-inject panel the trained task is saturated at every allocation while transfer halves, so the shared capacity transfer needs is strictly greater than the capacity the task itself needs.

Cross-task transfer falls monotonically as budget moves to the private expert (Figure 9), in both directions and robustly to concept resampling (Spearman 0.90-0.90, bootstrap [1.00,0.30][-1.00,-0.30] for G-inject; 1.00-1.00, [1.00,0.60][-1.00,-0.60] for U-inject). At the fully private G-inject endpoint, transfer is exactly at chance.

Matched-rank private-capacity control. We held shared rank fixed and added capacity on the private side at three matched shared ranks. Cross-task accuracy changed by 0.01-0.01 on average; the direct score at the fully private endpoint is 0.1170.117.

Appendix E The block-deletion experiment

Every measurement in §5.2 moves the entry point and reads depth off the layer index, so depth and downstream computation move together and the thesis’ own independent variable is never manipulated on its own. We therefore hold the site fixed at layer 7 and remove computation instead, making kk consecutive decoder blocks pass their residual stream through unchanged. Two windows of equal size are compared: the kk blocks immediately after the site, which the injected state must traverse, and the kk blocks immediately before it, which it never does.

Two design points matter. First, general damage is measured directly rather than assumed matched: a separate run over ordinary prompts containing no pseudo-name reports CLIP text–image agreement under the same ablation. Second, the patch is re-solved under each ablation, since a patch computed on the intact model is the wrong patch for a network missing four of its blocks.

Table 11: Deleting computation with the entry point held fixed at layer 7, identity (\uparrow). Every arm’s patch is re-solved under its own ablation. Δ\DeltaCLIP-T is measured on ordinary prompts containing no pseudo-name.
blocks deleted where which blocks concept identity Δ\DeltaCLIP-T (general ability)
0 0.828 [0.66, 0.97] ±0.0000\pm 0.0000
2 after the site 8, 9 0.742 [0.56, 0.91] 0.0065-0.0065
4 after the site 8–11 0.102 [0.02, 0.20] 0.0832-0.0832
6 after the site 8–13 0.016 [0.00, 0.05] 0.1084-0.1084
2 before the site 5, 6 0.000 [0.00, 0.00] 0.1018-0.1018
4 before the site 3–6 0.000 [0.00, 0.00] 0.0909-0.0909
6 before the site 1–6 0.000 [0.00, 0.00] 0.0879-0.0879

Measured block-deletion controls. We deleted k{2,4,6}k\in\{2,4,6\} consecutive blocks immediately before or after a fixed layer-7 entry point, re-solved the patch for every ablation, and measured both concept identity and Δ\DeltaCLIP-T on ordinary prompts. Table 11 reports both measurements; this ablation is not used for causal attribution.

Appendix F Parameter-sharing estimators

For one real training batch per direction we record the set of parameters each direction uses and report the parameter-count-weighted Jaccard overlap of the two sets. The backbone scope restricts this to the shared transformer stack and is the figure quoted in §6.2; the whole-model scope additionally charges each direction for its private codecs and heads.

Intersection estimator. We counted a parameter as used only when its module fired on a non-empty input and remained gradient-connected. Parameter names were canonicalized by tensor identity before computing the parameter-count-weighted Jaccard overlap. Hook-only, gradient-only, and intersection estimates are reported in Table 12.

Table 12: Measured cross-task parameter sharing for the two trained models under hook-only, gradient-only, and intersection estimators. Bold marks the reported intersection estimate.
backbone sharing by estimator
architecture params hook only grad only intersection whole model
BAGEL-7B-MoT (Deng et al., 2025) 14.1B 0.500 0.961 0.500 0.484
Janus-Pro-1B (Chen et al., 2025) 1.5B 0.873 0.873 0.873 0.720

Appendix G Per-model replication details

§6 groups four models by their understanding representation. Table 13 gives the evidence behind that grouping in full, so a reader can check the classification rather than take it.

Table 13: Every model in the four-architecture study. Injection module is the exact module list the forward hook was registered on; the patch always fires in the language backbone’s residual stream, never in a vision tower or a decoder, so “depth” means the same thing on all four. Sites are absolute block indices; 2-2 is the input embedding and 1-1 the last block’s output after the final norm.
model backbone understanding pathway generation pathway blocks
BAGEL-7B-MoT Qwen2.5-7B (MoT) ViT, semantic rectified flow, VAE latent 28
Janus-Pro-1B Llama, 1.5B SigLIP, semantic LlamaGen VQ 24
Omni-Diffusion-7B Dream-7B (Qwen2.5-7B) MagViT-v2 VQ masked discrete diffusion 28
Lumina-DiMOO-8B LLaDA-8B VQ codebook discrete diffusion 32
model injection module (hooked) sites probed / concepts / bank / ngenn_{\text{gen}}
BAGEL language_model.model.layers {2,0,3,7,10,14,17,21,24,25,26,27,1}\{-2,0,3,7,10,14,17,21,24,25,26,27,-1\} / 8 / 24 / 16
Janus language_model.model.layers {2,0,2,3,5,8,12,16,20,23,1}\{-2,0,2,3,5,8,12,16,20,23,-1\} / 12 / 12 / 8
Omni-Diffusion model.layers {2,0,2,3,7,10,14,21,24,1}\{-2,0,2,3,7,10,14,21,24,-1\} / 12 / 12 / 8
Lumina-DiMOO model.transformer.blocks {2,0,3,4,8,11,16,24,27,1}\{-2,0,3,4,8,11,16,24,27,-1\} / 12 / 12 / 8

For all four models we recorded the understanding pathway, generation pathway, backbone, scale, hooked module list, probed sites, concept count, bank size, and generation count before comparing their depth curves.

Full depth curves for the two 2026 models. We measured every probed site for both models. Lumina-DiMOO spans 0.0100.010 to 0.1670.167 against a floor of 0.1040.104, and Omni-Diffusion spans 0.0000.000 to 0.2500.250 against a floor of 0.2500.250. Per-site values are released with the code. Scaling the edit does not change either null: on Lumina-DiMOO at layer 4, α{1,2,5}\alpha\in\{1,2,5\} gives 0.0100.010, 0.0520.052 and 0.1460.146 against a base level of 0.1040.104, the last at 3.12×3.12\times the state norm; on Omni-Diffusion at layer 3 the same sweep gives 0.0000.000, 0.0830.083 and 0.0830.083 against a base level of 0.2500.250, the last at 2.57×2.57\times. Table 15 gives the per-model word-target instrument check at each model’s best site.

Table 14: The entry-point window on Janus-Pro against BAGEL at the nearest relative depth, identity (\uparrow). The intervention is identical in closed form, with all weights frozen and no gradient step; only the model changes. BAGEL figures are the seven-group values of Table 4 except where marked.
site relative depth Janus-Pro-1B BAGEL at the nearest relative depth
input embeddings 0.00 0.240 0.023 (embeddings, 1 group)
layer 0 0.04 0.344 0.323 (layer 0)
layer 2 0.12 0.583 0.528 (layer 3, rel. 0.14)
layer 3 0.17 0.427 0.528 (layer 3)
layer 5 0.25 0.281 0.584 (layer 7, rel. 0.29)
layer 8 0.38 0.146 0.366 (layer 10)
layer 12 0.54 0.135 0.040 (layer 14)
layer 16 0.71 0.094 0.047 (layer 17)
layer 20 0.88 0.062 0.038 (layer 24)
last block 1.00 0.073 0.039 (last block)
layer 3, deranged addresses 0.17 0.052 0.000
layer 5, deranged addresses 0.25 0.115
base model 0.052 0.036
LoRA trained on generation 0.625 0.724
Table 15: The word-target instrument check of §6.1, identity (\uparrow). Each row rotates a pseudo-name onto a target at the model’s best site through one code path; only the target differs. Percentages use each model’s measured floor and available trained ceiling. “<<floor” marks a score below the measured floor.
model site visual address real-word target floor trained ceiling
BAGEL-7B-MoT layer 7 0.584 (80%) 0.036 0.724
Janus-Pro-1B layer 2 0.583 (93%) 0.625 (100%) 0.052 0.625
Lumina-DiMOO-8B layer 4 0.010 (<<floor) 0.656 (6.3×\times floor) 0.104
Omni-Diffusion-7B layer 3 0.000 (<<floor) 0.500 (2.0×\times floor) 0.250

Appendix H Instance versus category

We evaluated instance identity separately from category identity using single assets drawn from Objaverse and same-category sibling controls.

We used 12 same-category sibling pairs, 24 concepts, formed into three groups of eight from four pairs each, and scored the same generations with a 24-way coarse bank, a 24-way fine bank, a two-way sibling comparison, and CLIP’s vision tower. On the understanding side, the two same-category names were compared directly. Figure 10 shows the three scorings of the same generations, and Table 16 reports every condition.

Figure 10: The same generations scored three ways. Gray is the bank the rest of the paper uses, where no distractor shares the target’s category; blue puts a same-category sibling in the bank; orange compares the target against that sibling alone, where the category carries no information at all.
Table 16: Instance identity, three fine-grained groups (24 concepts in 12 same-category pairs), accuracy (\uparrow). Coarse and fine are the same 24-wide width scored on the same generated images and differ only in whether one distractor shares the target’s category. Paired drop is coarse minus fine, differenced per concept. Chance is 0.0420.042 for the 24-way columns and 0.5000.500 for the two-way ones.
generation identity understanding
condition coarse fine paired drop vs sibling matching
base model 0.047 0.031 +0.016+0.016 [-0.01, +0.04] 0.484 0.529
G-inject (flow matching) 0.906 0.724 +0.182 [+0.09, +0.29] 0.758 0.688
U-inject (LM CE) 0.424 0.344 +0.081+0.081 [+0.02, +0.16] 0.706 0.925
anchor @14 + flow matching 0.966 0.888 +0.078+0.078 [+0.00, +0.18] 0.914 0.854
anchor @14 alone 0.802 0.747 +0.055+0.055 [-0.01, +0.13] 0.878 0.721
closed-form patch @ L7 0.323 0.307 +0.016+0.016 [-0.01, +0.04] 0.690 0.667

Evaluation coverage. We scored the same generations with coarse banks, fine banks containing same-category siblings, sibling-only comparisons, and CLIP’s vision tower. The fine-grained evaluation uses 24 sibling pairs; the 56-concept sweep uses distinct-category banks. CLIP-based scores are 0.6820.682 for G-inject and 0.8440.844 for anchoring plus flow matching.

Appendix I Protocol-level controls

Table 17 collects the three controls §5.2 draws on. The derangement row substitutes another concept’s address at the same magnitude and direction statistics, isolating the pairing from the perturbation; the two quarter-magnitude rows separate dose from site.

Table 17: Protocol-level controls for the entry-point sweep, group of eight, accuracy (\uparrow). The base model scores 0.2540.254 on matching and 0.0360.036 on identity.
control und. matching gen. identity evaluation role
layer 3, real addresses 0.887 0.930 reference condition
layer 3, deranged addresses 0.138 0.000 address-order control
layer 7, quarter magnitude 0.613 0.086 shallow-site magnitude control
layer 24, quarter magnitude 0.138 0.031 deep-site magnitude control
base model 0.254 0.036 unmodified reference

Table 18 collects five further controls on the same group: injection with the name–image pairing shuffled, injection from text alone, embedding-only injection on either side, a forgetting check on the underlying real categories, and open naming. No alternative route to the binding comes near either trained condition, the real categories survive intact, and open naming is the one column that separates the two injection directions. Cross-name retrieval, not tabulated, gives 0.7580.758 for a name’s own concept against 0.1020.102 for the other names of its group.

Table 18: Protocol-level controls, group of eight, accuracy (\uparrow). Identity is 24-way retrieval on generations and matching is the 4-way naming probe, both as in §3.2; open naming is the fraction of concepts for which the model volunteers the pseudo-word with no candidates in the prompt. Real-category is balanced accuracy on the underlying real categories, the forgetting check. Cross-name retrieval is reported in the text.
condition identity matching open naming real-category
base model 0.036 0.254 0.000 0.931
G-inject 0.758 0.600 0.000 0.931
U-inject 0.562 1.000 1.000 0.924
name shuffling, G-inject 0.016 0.000 0.000
text-only injection 0.055 0.238 0.000
embedding-only, generation side 0.172 0.238 0.000
embedding-only, understanding side 0.055 0.975 0.000

Appendix J Reproducibility

Every number in this paper is produced by a script in the accompanying code release, reading from a results directory that the same scripts write. Concept rendering is deterministic given the asset list and seed. Training runs are single-GPU and fully specified by their command lines, which are generated by one experiment-matrix module rather than written by hand, so a stage can be re-run to completion with one command and is idempotent per job. The aggregation scripts named in each section regenerate the corresponding table from the raw per-condition JSON.