Function Vector

A function vector is computed by extracting the sum of attention head outputs from specific layers during in-context learning demonstrations. When this vector is added to the residual stream of a zero-shot prompt, it causally induces the model to perform the demonstrated task. This demonstrates that the model compresses the algorithm of the task—not just the input-output mapping—into a direction in activation space. The effect is robust across different prompts for the same task, proving the vector encodes a generalized procedure rather than a specific lexical pattern.

Function vectors are derived by averaging the attention head outputs over a set of in-context learning demonstrations. The standard procedure involves:

• Running the model on multiple input-output pairs for a task
• Recording the summed output of attention heads at specific layers
• Computing the mean vector across all demonstrations This mean vector, when added to a new query's residual stream, steers the model to apply the demonstrated function. The extraction typically targets middle-to-late layers where task-level abstractions are formed, not early layers that process surface-level syntax.

Function vectors exhibit systematic generalization: a vector extracted for one instantiation of a task (e.g., translating English to French) transfers to novel inputs within the same task class. Furthermore, function vectors can be composed by adding vectors for different subtasks, enabling the model to execute multi-step procedures without explicit prompting. This compositional property suggests that the residual stream acts as a linear task space where independent algorithmic skills are represented as orthogonal directions that can be combined additively.

Function vectors are fundamentally different from the input embeddings of the demonstration tokens. While prompt embeddings encode the literal text, function vectors encode the causal mechanism that the prompt induces. Evidence for this distinction:

• Function vectors extracted from one set of demonstrations work on entirely different prompts for the same task
• They are localized to specific attention heads, not distributed across the full embedding
• Ablating the function vector after extraction removes the task behavior, even if the original prompt tokens remain This confirms that in-context learning creates a latent task representation separable from the surface form of the instructions.

Function vectors are not uniformly distributed across all transformer layers. Research shows they are concentrated in a critical window of middle layers (typically layers 8-16 in medium-sized models). These layers correspond to where the model transitions from processing token-level syntax to forming high-level semantic abstractions. Attention heads in these layers act as task-encoding modules whose outputs, when summed, define the function. Earlier layers handle input formatting, while later layers execute the task using the injected vector as a steering signal.

Function vectors are mechanistically related to induction heads, the attention patterns that enable in-context copying. While induction heads implement the primitive operation of 'attend to the token after a previous occurrence,' function vectors represent the compiled task program that emerges from orchestrating multiple such primitives. The function vector can be understood as the residual stream state that configures downstream attention heads and MLP layers to execute the task, effectively acting as a learned 'function pointer' that the model's forward pass dereferences into behavior.