acceptodds
Under review as a conference paper at ICLR 2027

Structure-Aligned Steering: Task-Space Operations for Activation Control

Abstract

Activation steering usually linearly adds a vector to a hidden state, imposing translation that disregards the inherent structure of the task (e.g., cyclical structure of weekdays). We introduce Structure-Aligned Steering, an encoder-decoder interface that maps hidden states into task-structured coordinates, applies transformations there, and returns model-readable states. With prescribed weekday coordinates, one rotation advances the output towards the next day, composes fractional steps with smooth output transfer between neighboring days, and closes the cycle, which can not be achieved by linear steering. Without clear coordinate targets, matching geometry-derived output distributions still yields compatible geometry: sparse number mixtures unfold into a continuous circle, and color encodings preserve RGB-cube neighborhoods and approximate distances, which the decoder carries into hidden states. Perturbing these coordinates or supervising with task-inconsistent geometry reduces accuracy, linking this organization to steering. To show practical value beyond mechanistic analysis, we build a steerer–aligner system for modular arithmetic that outperforms parameter-matched PEFT baselines across eight models. Task-space alignment thus makes steering structured and compositional rather than merely directional.

Primary area:
interpretability and explainable AI
Keywords:
activation steering, representation engineering, mechanistic interpretability, hidden-state geometry, task structure

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_KZZKOpenReview ↗
Rating
3(+1)
Confidence
1(−1)
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper introduces Structure-Aligned Steering, which encodes hidden states of a frozen language model into a low-dimensional space with explicit task structure, performs task-specific operations in that space, and decodes the results back into the model. Experiments on weekday cycles, number cycles, RGB colors, and modular arithmetic demonstrate the feasibility of incorporating explicit task rules into structured activation control.

Critical strengths
  1. The experimental evaluation is extensive and provides reasonably convincing evidence. The paper evaluates four tasks across eight models and includes supplementary analyses of intervention layers, random seeds, structural perturbations, and coordinate-region holdouts. The authors also report failure cases and transfer limitations, helping readers assess the scope of the findings. (§4, Appendices D–J)
  2. The framework is clear and offers a useful direction for future research. The encode–operate–decode design is intuitive and accommodates different task structures, including cycles and color spaces, within a common interface. It provides a useful approach to incorporating explicit task structure into language-model activation control. (§3)
  3. The evaluation of structured control goes beyond final-answer accuracy. The authors examine continuous interpolation, repeated operations, cycle closure, and distance preservation. The weekday experiments demonstrate the feasibility of continuous stepping and cyclic composition, while the broader analyses distinguish output correctness from structural consistency, providing a valuable evaluation perspective for future work. (§§4.1–4.2, Appendices A.4 and E.6)
Critical weaknesses
  1. The fairness of the baseline comparisons needs further examination. The proposed modular arithmetic system receives operand-level supervision and uses a predefined exact modular addition rule, whereas LoRA and Prefix Tuning are trained only on final answers. Matching parameter counts and training examples therefore does not isolate the contribution of the geometric interface: the performance gap may also reflect additional supervision and built-in computation. Comparisons with baselines using the same supervision and computational module would strengthen the evidence. (§4.3, Appendices B.6 and C.7)
  2. Generalization remains limited. Appendix G.6 reports that average modular arithmetic accuracy across models drops from 95.5% on the original prompt template to 30.4% on new templates, indicating substantial sensitivity to input phrasing. Moreover, experiments with different moduli and operand ranges retrain the entire system, providing limited evidence of transfer without retraining. (Appendices G.5–G.6)
Questions for authors
  1. Learning geometric structure: Both the input construction and output supervision contain task geometry. Could the authors include a fixed coordinate extractor with a learned decoder—for example, recovering coordinates from RGB mixtures using a linear pseudoinverse—to clarify the need for a learned encoder? Would similar geometric organization and performance emerge if semantic anchors were replaced with random linearly independent vectors?
  2. Structured baselines: Could the authors compare against a codebook-based method using the same inputs and supervision, which maps inputs to discrete entries, applies predefined cyclic or compositional rules, and directly outputs the corresponding labels? Appendix G.4 already shows that direct anchor injection matches the learned decoder on discrete modular arithmetic. This additional comparison would help clarify the unique benefits of the continuous geometric interface for task accuracy, continuous control, and compositional generalization. A good answer will improve the score.
  3. Training fairness and transfer: Could the authors report the full training budgets for the proposed method, LoRA, and Prefix Tuning, including interface pretraining, optimization steps, wall-clock time, and hyperparameter search ranges, and evaluate whether the baselines improve with more extensive training? For new prompt templates, could the authors also report baseline transfer performance and use oracle operands or oracle results to determine whether the proposed method’s degradation primarily arises from readout or write-back?
7 comments

Dear Reviewer KZZK,

Thank you for your detailed review. Our responses follow; the changes to the paper are in Revision Notes 3, 4, 5 and 7.


W1 and Q3 (training fairness)

Thank you for the suggestion to better demonstrate the contribution of our steerer by matching the training budgets of the steerer and the PEFT baselines. All experiments below use Qwen3-4B at layer 27.

(a) Budgets in the submission. We first report the budgets and hyperparameters.

ours: steererours: alignerLoRAprefix tuning
training promptspool of 18k, used as carrier contexts18k, 1 epoch18k, 1 epoch18k, 1 epoch
steps × batch size2,000 × 16563 × 32563 × 32563 × 32
backpropagation through the LLMyesno (MLP on cached states)yesyes
learning rate5e-45e-42e-42e-4
task labels usednoneoperands a and bfinal answerfinal answer
parameters565d259d851d840d

The aligner and the baselines were matched in examples, epochs, batch size and steps. Two things were not: the steerer has 2,000 additional steps, and the baselines' learning rate was fixed, not tuned. Experiment (b) removes both.

(b) Longer training with a tuned learning rate. We now train the baselines much longer, for 20 epochs, and sweep the same five learning rates (1e-4, 2e-4, 5e-4, 1e-3 and 2e-3) for every method. The learning rate is selected on a validation split, and the test set is evaluated once. LoRA is run with two scalings, α = r/2 as in the paper and α = 2r. For ours, the aligner is trained for 10 epochs, and the 2,000 steerer steps with batch size 16 correspond to about 1.8 epochs of the 18k prompts, so our method uses about 11.8 epochs in total, far fewer than the baselines. Training time is for one learning rate on one H200 and, for our method, includes the extraction of hidden states and the training of the steerer.

methodepochsselected learning ratetraining timeaccuracy on 500 training prompts (%)validation (%)test (%)
ours11.8 (aligner 10, steerer 1.8)5e-42.7 min100.094.093.0
LoRA, α = r/2202e-323 min100.067.657.4
LoRA, α = 2r201e-323 min100.064.860.4
prefix tuning202e-413 min60.232.635.0

More training does not close the gap. LoRA fits the training prompts perfectly, but its test accuracy stays far below ours. The test operand pairs do not occur in training, so LoRA lacks generalization to new pairs, not optimization, whereas our steerer achieves it. Our method also needs far less training time.

(c) The same operand supervision for LoRA. We add to LoRA an auxiliary head with the architecture of our aligner, which predicts the two operands from the output of the adapted layer. The training loss is the cross-entropy of the answer plus that of the two operands. Data, epochs, learning-rate grid and selection rule are those of (b). The head is discarded at inference, so the reported accuracy is that of LoRA's own answer.

systemvalidation (%)test (%)
LoRA67.657.4
LoRA + operand supervision85.883.6
ours94.093.0

Operand supervision brings LoRA a further gain, but it stays below ours. The remaining gap is not a lack of information: LoRA lacks a way to turn the result of the rule into the model's answer (the operands predicted by the auxiliary head, passed through the exact modular rule, give the correct result on 99.6% of the test prompts), and this write-back is what the interface provides. This is the advantage of the steerer over PEFT: a computation carried out exactly outside the model can be written back into it. In line with your point, the distinctive advantage of our system is therefore the combination of a read-out with operand supervision, an exact rule, and the write-back through the interface. The revised paper presents the gain in this way (see Sec. 4.3 and App. G.1).

W2 and Q3 (generalization and transfer)

Thank you for the suggestion to separate read-out errors from write-back errors on new templates, and for pointing out that our experiments on other operand ranges and moduli retrained the whole system. We again use Qwen3-4B at layer 27.

(a) Source of the degradation on new templates. Following your suggestion, we separate read-out errors from write-back errors: we replace the aligner's prediction by the true residue, and also the decoder by the constructed anchor of that residue. We evaluate on the original template and the four new templates of App. G.6 (500 test prompts each), and run the LoRA and prefix adapters selected in our reply to W1 on the same prompts.

templatealigner residue accuracyfull systemtrue residue + decodertrue residue + anchorLoRAprefix tuningunmodified model
original.872.8721.0001.000.576.358.246
words.442.434.9221.000.418.302.236
remainder.322.266.8021.000.294.350.354
function.140.1401.0001.000.274.236.214
instruction.268.2681.0001.000.338.234.194

When the true residue is given, the write-back is correct on all or most prompts of every template, and full-system accuracy follows the aligner's residue accuracy. The degradation therefore comes from the operand read-out, trained on a single template, and not from the interface. LoRA and prefix tuning degrade as well, and have no component that can be retrained separately.

(b) New templates: retraining the aligner only. We keep the steerer frozen and retrain the aligner for one epoch on 18,000 prompts drawn from several templates, once with the evaluated template left out and once with all five templates included (full-system accuracy).

templatealigner of the paperretrained, template left outretrained on all five templates
original.872–.810
words.434.602.738
remainder.266.354.618
function.140.556.802
instruction.268.494.814

Retraining the aligner alone recovers a large part of the accuracy on the new templates, also when the evaluated template was left out, and the steerer is not touched. The original template loses some accuracy because it now receives only a fifth of the retraining prompts.

(c) New operand ranges: retraining the aligner only. The paper retrained the whole system for the operand ranges 0–39 and 0–49. Here we keep the mod-7 steerer trained with operands 0–29, and retrain only the aligner for one epoch.

operand rangealigner of the paper, not retrainedaligner retrained onlytrue residue + decoderwhole system retrained (paper)
0–39.598.9241.000.910
0–49.460.9301.000.942

The write-back of the frozen steerer is exact on the new ranges, and retraining the aligner alone matches retraining the whole system.

(d) New moduli: retraining the aligner only. A steerer has one anchor per residue, so each modulus k needs its own steerer, and we use the mod-k steerers of the paper. The aligner predicts the two operands and does not contain the modulus, so we ask whether it must be retrained with the steerer: we reuse the mod-7 aligner without any training, and retrain only the aligner on mod-k prompts for one epoch.

modulus kmod-7 aligner, not retrainedaligner retrained onlytrue residue + decoderwhole system retrained (paper)unmodified model
5.516.9461.000.954.648
6.702.9081.000.934.372
8.756.9581.000.932.308
9.548.9121.000.952.338

Without training, the mod-7 aligner works only in part, because "mod k" in the prompt shifts the states it reads, as a new template does. Retraining the aligner alone matches retraining the whole system, and the write-back with the true residue is exact for every k.

Cost of retraining (one H200).

what is retrainedtraining time
aligner only (one epoch, with hidden-state extraction)13 to 16 s
whole system (steerer and one-epoch aligner)about 120 s

In all three cases, a change of the prompt distribution is handled by retraining the lightweight aligner at a small fraction of the cost. This is the modularity the paper claims: the steerer is reused unchanged, and only the read-out depends on the prompt.


Q1 (learning geometric structure)

Thank you for the suggestion to demonstrate the necessity of the encoder by comparing it with the pseudoinverse and random-anchor baselines. On the paper's tasks they show that a learned encoder is not required, so we also added a task in which it is.

(a) The two controls on RGB and Number. We use Qwen3-4B at layer 27 with five seeds and the paper's settings otherwise. The fixed extractor replaces the encoder by the frozen linear pseudoinverse of the anchor basis, and only the decoder is trained. Random anchors replace each token's unembedding direction by a random Gaussian vector of the same norm, with the encoder and decoder trained as usual.

encoder / anchorsRGB accuracyRGB distance correlationNumber accuracy
learned / semantic (paper)70.3±9.8%.8197.9±1.2%
fixed pseudoinverse / semantic73.8±1.7%1 (by construction)97.9±0.4%
learned / random63.4±9.7%.81±.0695.0±1.2%

The fixed pseudoinverse matches the learned encoder, and with random anchors the encoder still arranges its inputs by the task geometry, with somewhat lower accuracy. The reason is that the inputs of these tasks are anchor mixtures: the coordinates are linear in the input, so a linear extractor is exact, and any linearly independent vectors parameterize the task domain equally well. This agrees with the paper's theoretical framework, which neither assumes semantic anchors (Thm. 1) nor singles out one internal chart (App. A.1).

(b) A task in which the encoder must be learned. A learned encoder is needed when the input is a natural hidden state in which the task variable has not been computed. We therefore steer on prompts such as "(417, 286) -> ", with operands a and b between 0 and 999 and target residue r = (a + b) mod 100. The prompt does not name the operation, so the unmodified model is at chance. We use Llama-3.1-8B, for which every number from 0 to 999 is a single token, and read the last-token state ha,bh_{a,b} at layer 24 (three quarters of the depth, as in the paper). The encoder maps it to the coordinates c(r)=(cos⁡2πrT,sin⁡2πrT)T∈2,5,10,20,25,50,100c(r)=(\cos\frac{2\pi r}{T},\sin\frac{2\pi r}{T})_{T\in\\{2,5,10,20,25,50,100\\}}, the position of r on seven circles. The model represents numbers on circles of these periods, and a single circle of period 100, in the manner of the paper's mod-7 task, fails here (our reply to Reviewer dazJ, W2 and Q2, explains how the periods are chosen). The decoder writes a state back from them, and we train with L=∣E(ha,b)−c(r)∣22⏟encoder loss−∑jqjlog⁡pjfull(D(z^))⏟decoder loss+∣D(z^)−sˉr∣22/σ2⏟reconstruction,\mathcal L=\underbrace{\\|E(h_{a,b})-c(r)\\|_2^2}_{\text{encoder loss}}\underbrace{-\sum_j q_j\log p_j^{\mathrm{full}}(D(\hat z))}_{\text{decoder loss}}+\underbrace{\\|D(\hat z)-\bar s_r\\|_2^2/\sigma^2}_{\text{reconstruction}}, where z^=E(ha,b)\hat z=E(h_{a,b}) is passed to the decoder without gradient, qjq_j is the soft target of Eq. 7 over the training residues, and sˉr\bar s_r is the model's mean state when it is about to answer r, with σ\sigma its typical norm; the three terms follow the paper's losses (Eqs. 6 to 8). Details are in Sec. 4.3 and App. C.9, G.12 of the revised paper.

To test generalization, 20 of the 100 operand classes (an operand's last two digits) never appear in a training prompt, and independently 20 of the 100 residues never appear as a training answer. We compare three ways of reading the state, each with a decoder of the same architecture and loss. Ours is the learned encoder. The fixed linear extractor is the pseudoinverse map fitted on the same states and coordinates. Random input vectors is the counterpart of random anchors: every operand value gets a fixed random vector, and the encoder reads the sum of the two vectors instead of the model's state. Accuracy is the fraction of test prompts on which the model's top-1 token after the write is the correct residue (mean ± sd over five seeds).

read sideall seenan operand unseenresidue unseenboth unseen
ours1.000±.001.991±.003.949±.042.925±.037
fixed linear extractor.433±.028.223±.011.041±.011.020±.006
random input vectors1.000±.000.006±.002.949±.053.004±.003

The fixed linear extractor is lower in every column: the position of the residue on a circle is obtained by adding the angles of the two operands, which is a nonlinear function of how the operands are represented that a linear map cannot compute. Random input vectors are perfect when both operands were seen and at chance when one was not: a network can memorize a code for every seen value, but the vector of an unseen value carries no information. The learned encoder stays accurate on operands it never saw, so it relies on the model's own representation of numbers. Together with (a): anchor mixtures need only a linear extractor, whereas natural states, in particular with operands unseen in training, need the learned nonlinear encoder.

Reviewer_eSwgOpenReview ↗
Rating
3(+1)
Confidence
2(−1)
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper proposes Structure-Aligned Steering, an encoder–decoder interface that maps activations into task coordinates, applies a predefined operation, and maps the result back into the model. Weekday, number, and RGB experiments test whether the interface preserves task geometry and supports repeated transformations. For modular arithmetic, the system predicts operands, computes their sum using an explicit modular rule, and writes the result back through the interface. It outperforms parameter-matched adaptation baselines across eight models, though direct anchor injection achieves identical arithmetic predictions in the reported ablation.

Critical strengths
  1. The paper considers a relevant limitation of fixed-vector steering. Task operations such as advancing a weekday have cyclic structure that repeated addition of the same vector does not naturally capture.

  2. The experiments examine more than final answer accuracy. Tests of repeated steps, cycle closure, and intermediate outputs provide some evidence about whether the learned interface preserves task structure.

Critical weaknesses
  1. The practical gains are difficult to attribute to the proposed interface. The arithmetic system combines operand supervision with an explicit calculation rule, unlike the PEFT baselines. Direct anchor injection also matches the learned interface in the reported ablation. These results leave unclear why the learned interface is needed for this application.

  2. The method works mainly in carefully designed settings. The experiments show that the interface can realize the supplied task geometry, but this does not by itself demonstrate reliable control across contexts. The weaker transfer to unseen transitions and new prompt wording limits how far the findings can be generalized.

Questions for authors
  • What benefit does the learned interface provide for modular arithmetic beyond direct anchor injection, given their identical predictions?
  • How broadly does the learned interface generalize beyond the training setup, given its weaker performance on unseen transitions and new prompt wording?
9 comments

Dear Reviewer eSwg,

Thank you for your careful review. Our responses follow; the changes to the paper are in Revision Notes 4, 5, 6 and 7.


W1 and Q1 (what the interface adds)

Thank you for the suggestion to clarify where the gain of the Modular system comes from and what the learned interface adds over direct anchor injection.

(a) Where the gain over PEFT comes from. We trained LoRA with the same operand supervision as our aligner: an auxiliary head predicts the two operands during training and is discarded at inference (Qwen3-4B, layer 27; all methods use the same learning-rate grid and are selected on a validation split). The details are in our reply to Reviewer KZZK (W1 and Q3), which also shows that training LoRA and prefix tuning for 20 epochs with a tuned learning rate does not close the gap to our method.

systemtest accuracy (%)
LoRA57.4
LoRA + operand supervision83.6
ours93.0

Operand supervision brings LoRA a further gain, but it stays below ours. The remaining gap is not a lack of information. What LoRA lacks is a way to turn the result of the rule into the model's answer (when the operands predicted by the auxiliary head are passed through the exact modular rule, the result is correct on 99.6% of the test prompts), and this write-back is what the interface provides. This is the advantage of the steerer over PEFT: a computation carried out exactly outside the model can be written back into it. The distinctive advantage of our system is thus the combination of a read-out with operand supervision, an exact rule, and the write-back through the interface.

(b) Comparison with direct anchor injection. In the Modular system the aligner outputs a residue, and the decoder writes the state of that residue. The decoder is evaluated at seven discrete coordinates only, so it is used like a table of seven states, and it should match direct anchor injection. App. G.4 shows exactly this: at every residue the decoder is as effective as the constructed anchor, which is the upper bound, and the remaining errors come from the aligner's reading. We do not claim an accuracy gain over anchor injection in this setting. The advantage that is unique to the decoder appears under generalization, which we show in our reply to Reviewer KZZK (Q2). There the task is addition modulo 100 on Llama-3.1-8B, and 20 of the 100 residues never occur as a training answer. Codebook-type methods, which like direct anchor injection write one stored state per residue, cannot make the model produce any of the unseen residues, whereas our decoder does so on 94.9% of the prompts.

(c) Where the learned interface differs from raw anchors. We compare the steerer with two ways of injecting anchors directly, writing the nearest anchor and writing a linear mixture of the neighbouring anchors, in two settings on the Modular task (Qwen3-4B, layer 27). The first tests sparse anchors: as in the Number experiment (Sec. 4.2), only three of the seven residues have an anchor, and we measure the accuracy on the four residues without one when the true residue is written. The second tests graded control: the desired output is not a single residue but a distribution over the residues that shifts gradually from one residue to the next as the position moves along the circle (the soft target of Eq. 7 with temperature 0.5, compared with 0.1 in the standard steerer), and we measure the total-variation distance between the model's output distribution and this desired distribution.

state writtenaccuracy on residues without an anchordistance to the gradual target (lower is better)
learned interface1.000.043
nearest anchor.000.320
linear mixture of anchors.000.219

The learned interface has two advantages over raw anchors. First, it works when anchors are sparse: direct injection needs one anchor for every output, whereas the interface writes all seven residues from three anchors. Second, its output changes smoothly between residues: the nearest anchor gives a step and a mixture of anchors does not follow the desired distribution, while the decoder does. A smooth response makes the positions between residues usable, so the strength of each output can be set continuously, instead of only switching between stored states.

W2 and Q2 (unseen transitions and new templates)

(a) Unseen transitions. The test in App. E.6 fitted an affine map to the six seen transitions and applied it to digit 6. An affine map is not restricted to rotations, so this test measures whether a general linear step, estimated from six transitions, extrapolates to the seventh. It does not measure whether the operation that the learned circle itself defines, a rotation, carries 6 to 0. We therefore add this second measurement.

In the Number task the encoder places every digit on the unit circle, and the operation "+1" is a rotation of the circle. We set the rotation angle to the circular mean of the six seen steps (from digit j to digit j + 1, for j from 0 to 5). We then rotate the coordinate of digit 6 by this angle once, decode it, and check whether the model outputs 0. Nothing is retrained, and the steerers are those of the paper. As a second choice we use the ideal angle 2π/7. As a control, we apply the same procedure to steerers trained with the two wrong geometries of App. E.6, a shuffled circle and a line.

step applied to digit 6models on which the output is 0
rotation by the mean of the seen steps7 of 8
rotation by 2π/77 of 8
same rotation, steerer trained on a shuffled circle0 of 3
same rotation, steerer trained on a line0 of 3

With the native rotation, the unseen transition is reached on seven of the eight models. On steerers trained with a wrong geometry the same rotation does not produce 0, so this success depends on the learned circular geometry and is not a trivial property of the decoding. The exception is Llama-3-70B, on which the learned arc from 6 to 0 is wider than one shared step. Together with the affine result of App. E.6 (3 of 8 models), this gives a consistent picture: the learned circle is approximately, but not exactly, evenly spaced, and the rotation that the geometry defines crosses the unseen transition on most models, more reliably than a free affine map estimated from six transitions.

(b) New prompt templates. To find the source of the degradation on new templates (App. G.6), we separate read-out errors from write-back errors (Qwen3-4B, layer 27). Our system reads the two operands with the aligner, applies the modular rule, and writes the state of the resulting residue with the decoder. We replace the aligner's prediction by the true residue, and also the decoder by the constructed anchor of that residue. We evaluate on the original template and the four new templates (500 test prompts each), and run LoRA and prefix tuning, trained for 20 epochs with a tuned learning rate, on the same prompts.

templateresidue accuracy of the alignerfull systemtrue residue + decodertrue residue + anchorLoRAprefix tuningunmodified model
original.872.8721.0001.000.576.358.246
words.442.434.9221.000.418.302.236
remainder.322.266.8021.000.294.350.354
function.140.1401.0001.000.274.236.214
instruction.268.2681.0001.000.338.234.194

When the true residue is given, the write-back is correct on all or most prompts of every template, and full-system accuracy follows the aligner's residue accuracy. The degradation therefore comes from the operand read-out, trained on a single template, and not from the interface. LoRA and prefix tuning degrade as well, and have no component that can be retrained separately.

We then keep the steerer frozen and retrain only the aligner for one epoch on 18,000 prompts drawn from several templates, once with the evaluated template left out and once with all five templates included (full-system accuracy).

templatealigner of the paperaligner retrained, template left outaligner retrained on all five templates
original.872–.810
words.434.602.738
remainder.266.354.618
function.140.556.802
instruction.268.494.814

Retraining the aligner alone recovers a large part of the accuracy on the new templates, also when the evaluated template was left out, and the steerer is not touched. The original template loses some accuracy because it now receives only a fifth of the retraining prompts. The learned interface therefore generalizes beyond its training setting, and the read-out is the component to retrain. The same holds for new operand ranges and new moduli (our reply to Reviewer KZZK, W2 and Q3): with the true residue the write-back is exact in every setting, and retraining the aligner alone, which takes 13 to 16 s against about 120 s for the whole system, matches retraining the whole system.


We appreciate the effort you put into this review. If our answers resolve your concerns, we would be grateful if you would consider updating your evaluation.

Dear Reviewer eSwg,

We sincerely thank you for your time and thoughtful consideration of our manuscript. As the discussion period approaches its conclusion, we hope our responses have adequately addressed your concerns. We would greatly appreciate any further feedback you may have. Thank you again for your valuable input and consideration!

Reviewer_dazJOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
3
Read review
Paper summary

This paper proposes Structure-Aligned Steering, which aims to make activation steering more semantically meaningful by aligning hidden representations with task-specific geometric structures. Instead of directly adding steering vectors in hidden-state space, the method learns an encoder-decoder interface that maps hidden states to task coordinates, performs structured operations (e.g., rotations for cyclic groups), and maps the results back to hidden states. The authors consider both directly supervised coordinates and an end-to-end objective that encourages geometric alignment through output distributions. Experiments cover weekdays, numbers, RGB colors, and modular arithmetic across multiple LLMs.

Critical strengths
  • interesting intuitive idea
  • comprehensive experiments: extensive experiments across multiple models, baselines and ablations
  • geometry without direct coordinate supervision is cool
Critical weaknesses
  1. The practical motivation for structured steering is not sufficiently clear. My main concern is why activation steering actually needs to preserve these task structures, especially for interpretability applications. For example, it is not that we cannot steer Monday to Sunday with linear steering; it is just that a fixed direction cannot preserve the complete cyclic order or satisfy repeated composition. However, why do we need cyclic order in the first place? The paper demonstrates that the proposed method can achieve this property, but I am not fully convinced when or why this property is necessary in practice. I would like to see a more concrete example where semantically or logically consistent transformations are essential for steering, rather than just being a desirable mathematical property.

  2. The applications are still quite restricted. Although the experiments are comprehensive, three of the four tasks (Weekday, Number, and Modular) essentially share the same circular structure, while RGB provides a three-dimensional extension. These are settings where the task geometry is already well defined.

  3. Given that the target output distribution in Eq. (7) is explicitly constructed using distances in the prescribed task space, I find the emergence of compatible geometry somewhat unsurprising. I understand that the encoder coordinates are not directly supervised and are not uniquely identified by the objective, so the empirical findings are still interesting. However, I would appreciate a clearer discussion of what is genuinely learned beyond the geometric information already provided by the objective.

  4. The presentation and formalization could be simplified. I found the preliminary formalization in Section 3.1 somewhat difficult to follow relative to the core idea. In my understanding, the overall method can be summarized quite simply as:

Hidden state → Encoder → Task coordinates → Structured operation → Decoder → Modified hidden state.

Introducing this intuition clearly at the beginning would make the paper much easier to understand. I am also not sure whether the current level of formalization is necessary, especially given that some theoretical results follow from standard approximation arguments or properties of the chosen objective.

Questions for authors

See weakness above.

  1. A small comment is that you can try to extend this to other geometries, like trees, and look at non-Euclidean distances when you are building the mixture.
  2. I wonder what would happen if the method were applied to a task without an obvious natural geometry. Would choosing an arbitrary geometry still produce meaningful steering results? The authors already consider incorrect geometries, but only for tasks where the intended geometry is known. I think what is more interesting and practically meaningful is to unveil some unknown geometries with your tool, if possible.
10 comments

Dear Reviewer dazJ,

Thank you for your constructive review. Our responses follow; the changes to the paper are in Revision Notes 1, 2 and 8.


W1, and the tree / non-Euclidean geometry suggested in W2

Thank you for highlighting the need to evaluate our steerer where semantically or logically consistent transformations are essential for steering. We have added such a task: steering the model's output among the concepts of a three-level geographic hierarchy of continents, countries and cities. This setting is of more practical interest than Weekday, and relations between places have been studied extensively [1, 2]. Consistent transformations are necessary here: to succeed, especially under composition, a method must represent a move between levels, such as from a city to its country, by one semantically consistent transformation that is correct for every city. The concepts form a hierarchical tree, so the task also meets your request for non-Euclidean geometry. We use three continents, six countries per continent and three cities per country; with the root, whose concept is "globe", this gives 76 nodes (see App. K of the revised paper).

How the tree enters the latent space. Every node except the root has one edge to its parent, so the tree has 3+3×6+3×6×3=753+3\times6+3\times6\times3=75 edges, and the reference coordinate has one dimension per edge. A node vv is placed at c(v)∈0,175c(v)\in\\{0,1\\}^{75}, with c(v)e=1c(v)_e=1 if edge ee lies on the path from the root to vv. Writing exe_x for the unit vector of the edge entering node xx, for example c(Munich)=eEurope+eGermany+eMunichc(\text{Munich})=e_{\text{Europe}}+e_{\text{Germany}}+e_{\text{Munich}}. The task distance is the tree path length, dT(u,v)=∣c(u)−c(v)∣1d_T(u,v)=\\|c(u)-c(v)\\|_1, the number of edges between uu and vv. A point zz at fraction tt of the edge from vv to its parent mixes their coordinates, and its anchor mixture hmix(z)h_{\mathrm{mix}}(z) their anchors (Eq. 4), with weights 1−t1-t and tt. The operations are fixed maps on coordinates: moving up one level removes the last edge of c(v)c(v), moving from a country to its capital adds the capital's edge, and the lowest common ancestor (LCA) of two places is their coordinate-wise minimum.

Steerer, prompts and loss. We use Qwen3-4B and intervene at layer 27. The encoder and decoder architecture (Eq. 5) and the anchor construction (Eq. 3) are those of the paper's other tasks. We steer on two kinds of prompts: a carrier prompt as in the paper's other tasks ("The place is"), and natural prompts such as "My grandmother was born in Munich, and my mother was also born in", which the unsteered model completes with Munich. We include natural prompts because they are closer to practical use and best suited to CAA [3], our steering baseline. We train the steerer with L=∣E(hmix(z))−z∣22⏟encoder loss−∑jqj(z)log⁡pjfull(D(z))⏟decoder loss+∣E(hnat(v))−c(v)∣22⏟natural-prompt loss,\mathcal L=\underbrace{\\|E(h_{\mathrm{mix}}(z))-z\\|_2^2}_{\text{encoder loss}}\underbrace{-\sum_{j}q_j(z)\log p_j^{\mathrm{full}}(D(z))}_{\text{decoder loss}}+\underbrace{\\|E(h_{\mathrm{nat}}(v))-c(v)\\|_2^2}_{\text{natural-prompt loss}}, where zz is sampled uniformly along the edges, qj(z)q_j(z) is the soft target of Eq. 7 with the tree distance dTd_T over the 76 nodes, and hnat(v)h_{\mathrm{nat}}(v) is the layer-27 state of a natural prompt that mentions place vv. The encoder loss is that of the Weekday steerer (Eq. 6), and the decoder loss is that of Number and RGB (Eqs. 7 and 8). The natural-prompt loss trains the encoder to read natural-prompt states, and during training the decoder output is also written into natural prompts. We train on five natural-prompt templates and test on three unseen ones.

Baseline. To steer from A to B, CAA adds the difference between the mean hidden state on which the model outputs B and the mean state on which it outputs A, scaled by a coefficient α\alpha. For the carrier prompt and for natural prompts separately, we compute one CAA vector per level: for city→country, the mean state of all countries minus the mean state of all cities. The vector is added at layer 27 with one coefficient for all operations (α=4\alpha=4, chosen on validation templates).

Main result. The table reports accuracy per operation (ours: mean ± sd over five seeds; CAA is seed-independent).

operationcarrier: ourscarrier: CAAnatural: oursnatural: CAA
city→country1.000±.000.093.918±.017.720
country→continent1.000±.000.333.993±.010.852
city→continent1.000±.000.370.942±.040.429
country→capital1.000±.000.611.981±.026.889
any level→root1.000±.0001.000.999±.002.955

CAA matches ours only when every starting place has the same target (the root). Whenever the target depends on the starting place, ours is accurate and CAA is lower, most clearly on the carrier prompt.

(Continued) Beyond accuracy. Two further experiments show the advantage of the steerer over linear steering methods such as CAA: (1) the lowest common ancestor, an operation specific to trees, tests whether the steerer has learned the geometry of the tree; (2) a counterfactual tree tests whether, as formulated in Sec. 3.1, the steerer realizes whatever task space it is given, independently of the relations the model already knows.

(1) The steerer computes lowest common ancestors; averaging does not. The LCA of two places is the lowest node that contains both: Germany for Munich and Hamburg, Europe for Munich and Milan, the root for Munich and Tokyo. We test all (762)=2,850\binom{76}{2}=2{,}850 pairs of nodes on the carrier prompt. For a pair (u,v)(u,v), the steerer encodes the two anchors, zu=E(au)z_u=E(a_u) and zv=E(av)z_v=E(a_v), takes their coordinate-wise minimum, which keeps exactly the edges shared by the two root paths, and writes the decoded state into the carrier prompt. The output is correct if the model names the LCA. We compare with two linear baselines: the average of the two anchors, (au+av)/2(a_u+a_v)/2, and this average plus one added vector (the mean displacement from the average to the LCA anchor, with the best coefficient on the evaluated pairs). Columns group the pairs by LCA level.

methodall 2,850 pairsLCA = root (1,950)LCA = continent (792)LCA = country (108)
ours1.000±.0001.000±.0001.000±.0001.000±.000
average of the two anchors.039.034.047.065
average + vector.684.999.001.000

The average of two places is not their common ancestor, and an added vector helps only when the answer is always the root. The LCA is defined by the tree and has no linear counterpart. The steerer has therefore learned the non-Euclidean geometry of the tree.

(2) The steerer executes the specified mapping even when it contradicts the model's knowledge. In the main table CAA is close to ours in some settings, such as country→capital on natural prompts, but the model may be answering from its own knowledge of geography instead of following the CAA vector. We therefore build a counterfactual tree with the same nodes and shape but memberships unrelated to real geography: for example, the real chain Madrid → Spain → Europe becomes Madrid → Iran → Africa. We retrain the steerer and recompute the CAA vectors on this tree, and compare them on natural prompts; the last column reports how often CAA outputs the real-tree answer.

operationoursCAACAA outputs the real-world answer
city→country.932±.019.000.739
country→continent.852±.052.037.889
city→continent.939±.025.230.435
country→capital.826±.028.000.870

CAA fails on the counterfactual tree and often outputs the real-world answer instead, so its accuracy on the real tree comes largely from knowledge the model already has. The steerer continues to carry out the mapping it was given.

Function vectors. Todd et al. [1] report that adding a function vector can implement relations such as country→capital, so we also test it. Following their procedure, we build 10-shot prompts for each operation (for city→country, ten lines such as "Madrid: Spain" followed by the query line "Munich:"), select the ten attention heads with the largest average indirect effect, and sum their mean outputs. We evaluate the function vector on its own zero-shot prompt ("Munich:"), add it at each layer from 6 to 27 with 11 coefficients per layer, and report the best result per operation.

operationfunction vectorours (natural prompts)
city→country.889.918±.017
country→continent.500.993±.010
city→continent.167.942±.040
country→capital.444.981±.026
any level→root.000.999±.002

Even with layer and coefficient chosen per operation on the evaluation items, the function vector is close to ours on one operation only.

[1] Todd et al. Function Vectors in Large Language Models. ICLR 2024. [2] Hernandez et al. Linearity of Relation Decoding in Transformer Language Models. ICLR 2024. [3] Panickssery et al. Steering Llama 2 via Contrastive Activation Addition. 2023.

W2, Q2 and W3

Thank you for reminding us to go beyond tasks whose geometry is predefined, and in particular for suggesting that our method be used to unveil unknown geometry. We add two experiments: (1) assigns a geometry to items that have none, and (2) uses the steerer framework to discover a hidden geometry.

(1) An arbitrary geometry on items with no natural geometry. We repeat the paper's Number experiment unchanged, except that the seven digits are replaced by seven unrelated words placed on the circle in an arbitrary order, for example golf, mountain, butterfly, coconut, piano, shovel, museum. Unlike numbers, these words have no intrinsic geometric relation to one another. As in Number, only three of the seven words have anchors, and training uses output supervision only. We use five word sets and five training seeds on all eight models of the paper at their layers. As in the paper, an output at one of 512 random positions on the circle is correct if it is the nearest word.

modelsteerer (mean ± sd over seeds)
Qwen3-1.7B.939±.013
Qwen3-4B.953±.011
Qwen3-8B.944±.012
Qwen3-14B.951±.008
Llama-3.2-3B.956±.009
Llama-3-8B.956±.011
Llama-3.1-8B.942±.010
Llama-3-70B.936±.008

On every model the steerer follows the imposed ring accurately. An arbitrary geometry therefore still gives meaningful steering.

(2) Using the tool to find the geometry a model uses. Extending the paper's mod-7 experiment, we consider addition modulo 100 on Llama-3.1-8B, for which every number from 0 to 999 is a single token. The prompt is "(a, b) -> ", for example "(417, 286) -> ", and the target is the residue r = (a + b) mod 100; the unmodified model is at chance. The encoder maps the prompt state to the position of r on a set of circles, and the decoder writes the answer back (details in Sec. 4.3 and App. C.8, C.9, G.12 of the revised paper). Our replies to Reviewer KZZK (Q1 and Q2) use the same task: there the learned encoder stays accurate on unseen operands where a fixed linear extractor does not, and the decoder writes residues that a codebook cannot. Unlike in the paper's Modular task, 20 of the 100 residues never appear as a training answer, and we ask whether the model can produce them.

We first follow the paper's mod-7 setting with a single circle of period 100, and then use the geometry that the task suggests, circles of periods 100 and 10 for the two digits of the residue. With the latter the supervised residues are produced, but the unseen ones much less often (0.542 against 0.993; first two rows of the table). Unlike in the mod-7 task, the model thus also uses circles of other periods to represent numbers in its natural hidden states, and we test which ones. For a candidate period T, we fit a linear map from the states in which the model is about to output a number n (0 to 999) to the position of n on the circle, on four fifths of the numbers, and measure R² on the rest. Periods 2, 5, 20, 25 and 50, which are factors of 100, give a high held-out R², whereas periods that are not factors, such as 3, 7, 13, 30 and 11, give a low one. A plausible reason is resolution: neighbouring numbers are only 3.6° apart on a circle of period 100, so shorter periods are needed to tell them apart, as rotary position embeddings use several frequencies for positions. We then train the steerer with each of these two kinds of circles added to periods 10 and 100 (mean ± sd over five seeds).

periodsheld-out R² of the added circlesunseen residues read correctlymodel accuracy, seen residuesmodel accuracy, unseen residues
100–.434±.022.352±.017.000±.000
10, 100–.991±.002.993±.004.542±.115
10, 100 + 2, 5, 20, 25, 50.91 to .99.999±.0011.000±.000.978±.019
10, 100 + 3, 7, 13, 30, 11−.29 to −.08.042±.015.992±.005.102±.010

Adding the circles that are fitted well makes the unseen residues both readable and writable. Adding the same number of circles that are not fitted, and thus absent from the model's hidden states, is worse than adding nothing: the supervised residues are still produced, but the unseen ones can no longer be read. The steerer framework can therefore be used to discover the geometry hidden in the model's hidden states.

(3) What is learned beyond the objective (W3). The held-out residues of (2) appear in no training target: they are neither reference tokens of the objective (Eq. 7) nor reconstruction targets. With the well-fitted circles the steerer still makes the model produce them, so this ability comes not from the objective but from the model's own organization of numbers, which the interface makes addressable through coordinates. This is the hidden geometry that the steerer framework uncovers.

Comments on the paper

1 comment
AuthorsOpenReview ↗

Revision Note

Dear PCs, SACs, ACs, and Reviewers,

Thank you for your valuable suggestions, which we addressed with the following adjustments to the paper. (Revisions are highlighted in purple.)

1. Reviewer dazJ: Evaluate the steerer where consistent transformations are necessary, on a non-Euclidean geometry (Section 3.2, Appendix K) We agree with the reviewer's suggestion and add a tree-structured task: steering among continents, countries and cities. Consistent transformations are necessary here, because a move from a city to its country must be one transformation correct for every city. The steerer outperforms the CAA and function-vector baselines, also on lowest common ancestors, a tree-specific operation, and on a counterfactual tree that contradicts the model's knowledge. This shows that the steerer can learn a non-Euclidean geometry.

2. Reviewer dazJ: Tasks without a natural geometry, and using the method to find an unknown geometry (Appendix D.5; Section 4.3, Appendix C.8) We agree with this remark. First, seven unrelated words on an arbitrary ring are steered accurately on all eight models, so the steerer also works on items with no intrinsic geometry. Second, on addition modulo 100, a held-out linear test identifies the circles on which the model represents numbers. A steerer built on these circles makes the model produce residues that never appear in a training target, whereas the task-suggested circles alone, or circles absent from the model's hidden states, do not. This shows that the steerer framework can also unveil geometric information from the model's hidden states.

3. Reviewer KZZK: Necessity of the learned encoder (Section 4.3, Appendix G.12) We concur that the learned encoder should be tested against a pseudoinverse extractor and random anchors. On RGB and Number both controls work about as well, because the inputs are anchor mixtures: the coordinates are linear in the input, so a linear extractor is exact, and any linearly independent vectors parameterize the task domain equally well. On natural states (addition modulo 100), a fixed linear extractor is far less accurate and random input vectors fail on unseen operands, whereas the learned encoder remains accurate. This shows the advantage of the learned encoder in generalizing the geometry to unseen cases.

4. Reviewer KZZK, eSwg: Necessity of the continuous decoder, compared with codebooks and direct anchor injection (Section 4.3, Appendix G.12) We agree with the reviewers' suggestion. When every label is supervised, as in the mod-7 task, both tie with the decoder. With modulus 100 and held-out residues and operands, a codebook cannot write a residue that was never supervised, and one that reads the operands also fails on unseen operands, whereas the decoder generalizes to both. This shows the advantage of a continuous decoder over codebook-type methods.

5. Reviewer KZZK, eSwg: Fairness of the comparison with PEFT, and the source of the Modular gain (Section 4.3, Appendix G.1) We agree with the reviewers' suggestion. We report the full budgets, train LoRA and prefix tuning for 20 epochs (far more than our system) and sweep across five learning rates; the advantage of our steerer remains. Giving LoRA the same operand supervision brings a further gain, but it stays below our system. This shows that the distinctive advantage of the steerer is the combination of operand supervision, an exact rule, and the write-back through the interface.

6. Reviewer eSwg: Crossing a transition that was not seen in training (Appendix E.6) We understand the concern about the weak transfer from 6 to 0. The submission's affine step is not restricted to rotations, so we add a test of the operation that the circular geometry itself defines: this rotation reaches the unseen transition on seven of eight models, and on no steerer trained with a wrong geometry. This shows that the steerer has learned the circular geometry and that its own operation crosses the boundary.

7. Reviewer eSwg, KZZK: Generalization across templates, operand ranges and moduli (Appendix G.11) We agree with the reviewers' suggestion. On new templates, operand ranges and moduli, the write-back is correct given the true residue, so the errors come from the read-out. Retraining the aligner alone recovers much of the accuracy on new templates and matches retraining the whole system on new ranges and moduli. This shows the modularity of the interface: only the read-out depends on the prompt.

8. Reviewer dazJ: Presentation of Section 3 (Section 3, Appendix A.6) We agree that the formalism came before the intuition. Section 3 now starts from the intuition, describes the task space through coordinates, a distance and operations, and states Theorem 1 informally; the general formalism and formal theorem are in the appendix.

We sincerely appreciate your time; your feedback has substantially strengthened the paper.

Sincerely, The Authors

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.