What PID Controllers Taught Me About Steering AI

How activation steering connects control theory, vector spaces, numerical analysis, and AI alignment.

Steering AI through feedback, vector spaces, and control theory.

People usually think that to improve something, we have to retrain it in some way.

We see the same thing with AI models. When people think about improving them, they often think about more data, more GPUs, more fine-tuning, and more parameters.

But this paper made me think about AI differently.

Paper: https://arxiv.org/abs/2510.04309?

Like driving a Tesla, you have autopilot, which allows you to not always drive it. Sometimes, you just need to steer it accurately.

That leads to a bigger question:

What if we do not always need to retrain the model?

What if we can steer it?

In the research paper “Activation Steering with a Feedback Controller,” the authors present a powerful idea: large language models can be treated like dynamical systems.

Instead of only looking at the final output. We can look inside the model at its hidden activations. By mathematical states that form as the model processes language.

So instead of asking, “How do we change the model’s weights?”

We can ask, “How do we control the model’s internal trajectory?”

That is where control theory enters the picture.

The same mathematical ideas used to stabilize drones, industrial machines, robots, and feedback systems can be applied to steering the behavior of large language models.

That idea is what made this paper stand out to me.

From linear algebra and vector spaces to control theory and AI alignment—visualizing how activation steering guides a model’s internal trajectory

What Is Activation Steering?

When using a large language model, we usually only see the final output.

But internally, something much more complex is happening.

For example, as a problem moves through a layer of a transformer, it builds hidden layers of mathematical representations, which are called activations.

The research models this process as:

x(1) → x(2) → x(3) → … → output

Where each layer updates the model’s internal state.

The researcher discovers that certain behaviors inside an LLM can behave like a direction activation space.

For example, I like to think of it as harmful behavior and harmless behavior. These are two different states a model can be in. Which can correspond to different actions.

Activation steering works by modifying these hidden activations during inference.

Instead of retraining the model’s weights, researchers “push” the activations toward a desired direction.

One of the core ideas in the paper is computing a steering direction using:

target behavior − source behavior

For example:

harmless activations − harmful activations

This creates a steering vector that guides the model toward the desired behavior.

Visually, it looks something like this:

harmful behavior — — — — — — — — -> harmless behavior

steering vector

At a high level, the model is not being rebuilt.

It is being guided.

“Breaking Down the Geometry of Activation Steering”

At first glance, activation steering can sound and look abstract.

But visually, the idea becomes much easier to understand.

The image above shows how researchers treat a language model’s hidden activations as points inside a high-dimensional vector space.

1. Activations Live in Vector Space

For example, as the prompt moves through the layers of a transformer, the model continuously updates its internal activation states:

x(1) → x(2) → x(3) → …

Each activation can be thought of as a vector inside a massive mathematical space.

In modern LLMs, this space can contain thousands of dimensions.

2. Behaviors Become Directions

One of the coolest ideas in activation steering is that behaviors can correspond to directions inside activation space.

For example, let’s use the example before harmful behavior and harmless behavior.

This can all create different activation patterns.

Researchers compute the average activation of two different behaviors:

Like, think of this target behavior—source behavior

This creates a steering vector.

Visually, the vector points from one behavioral region toward another.

That is why activation steering feels deeply connected to linear algebra and geometry.

3. Steering the Activation Trajectory

The lower part of the diagram is where the control theory becomes powerful.

Instead of viewing activations as isolated vectors. I found it astonishing the paper treats the model’s hidden states as a trajectory evolving through layers.

Without steering, the trajectory can drift. From a statistical perspective, in other words, the model’s internal trajectory can accumulate error across layers.

With steering, the trajectory is continuously corrected toward the target behavior.

This is very similar to feedback systems used in robotics and drones, which surprise me more even quantitative finance systems

The model is not being rebuilt.

It is being guided through activation space.

4. What and why PID Matters

First, what is PID?

PID stand for Proportional Integral Derivative.

P = Present error

How far are we from the target right now?

I = Past error

Have we been drifting away from the target over time?

D = Future trend

Are we changing too fast and about to overshoot?

The paper’s key contribution is adding PID control to activation steering.

Instead of reacting only to the current error, the controller also remembers past errors, predicts future instability, and reduces overshooting.

This reminded me of numerical analysis because many numerical methods are not just about getting an answer. They are about controlling error as a process evolves step by step.

Mathematically, this creates a more stable steering process across layers.

I like to think about it as turning activation steering into a true feedback control system.

“The Moment the Paper Clicked for Me”

The moment this paper truly clicked for me was when I stopped thinking about large language models as static prediction machines. I started thinking about them as evolving dynamical systems.

As someone studying statistics, financial mathematics, and numerical analysis, this perspective immediately felt familiar.

In numerical analysis, we often study how small errors behave through iterative processes. A method may look stable at the beginning. As each step builds on the previous one, the tiny errors can accumulate, which can cause drift, oscillation, or even explosion if the system is not controlled properly.

This paper showed me something similar happening inside large language models.

As activations move layer by layer through a transformer, the model is constantly updating its internal state:

x(1) → x(2) → x(3) → …

Without steering, the model’s hidden states can drift through activation space. This allows behavioral error to accumulate layer by layer.

That is why the PID framework stood out to me.

Instead of reacting only to the current error, the controller also remembers past error, predicts future instability, and reduces overshooting.

That idea felt deeply connected to concepts from numerical methods.

The model is not simply generating text.

It is evolving through a high mathematical trajectory.

As an undergrad, I like to think of regression like this:

In regression, we often think about prediction as projection in a high-dimensional vector space.

The model finds the best direction that minimizes error.

Activation steering feels similar. The model’s hidden states move through a high-dimensional space. The steering vector acts like a direction that projects the model closer to the desired behavior.

So instead of only predicting an output, we are guiding the model’s internal geometry.

And PID steering acts like a feedback system that continuously stabilizes that trajectory as the computation unfolds.

That was the moment the paper stopped feeling like just another AI paper to me.

It started feeling like applied mathematics, control theory, and machine learning all converging together.

Final Reflection

Before reading this paper, I mostly thought about AI improvement through training: more data, larger models, and more compute.

But this paper shifted my perspective.

It showed me that intelligence is not only about learning. It is also about control, stability, and trajectories through high-dimensional space.

As someone studying statistics, financial mathematics, and numerical analysis, that idea felt surprisingly natural.

In many mathematical systems, the challenge is not simply producing an output. The challenge is controlling how error evolves over time.

This paper applies that same philosophy to large language models.

And to me, that is what makes activation steering so cool.

The future of AI may not only depend on building larger models.

It may depend on learning how to guide them.

References

• Activation Steering with a Feedback Controller https://arxiv.org/abs/2510.04309?utm_source