the steering layer

Humans interact as someone. We understand what is going on, and we hold a faint intuition of the next action that gets us to the result we want.1Conversation runs on real machinery: turn-taking is a formal, locally managed system (Sacks, Schegloff & Jefferson 1974, Language), the gap between turns averages roughly 200ms across ten languages, which means listeners predict the next move before the current one ends (Stivers et al. 2009, PNAS), and shared understanding is built incrementally through grounding (Clark & Brennan 1991). We expect AI systems to be so strong that, with a little steering, they would do the same but better.

But the design we create and test for a system doesn't hold at runtime. AI gets put in real positions like CS representatives, specific characters, companions, where we test if it works: feels natural, gets the job done, reads like the person we would want. Yet at runtime the same system turns unpredictable, eventually making mistakes no person would make, forgetting facts, avoiding basic tasks, switching personality mid-chat.2Persona adherence decays within about eight turns as attention over the persona tokens fades (Li et al. 2024, COLM 2024), and larger models drift more, not less (Choi et al. 2024). The exchange degrades with it: performance drops about 39% from single-turn to multi-turn, and a model that takes a wrong turn does not recover (Laban et al. 2025, ICLR 2026 Outstanding Paper). As conversations go on, the statelessness of AI causes it to lose track of what situation it is in and who it is supposed to be. Every unnatural move then gets a new instruction in the system prompt, and every mistake gets a new rule added as well, but these solutions don't hold and start diluting the design we created.3Content in the middle of a long prompt gets used far less than content at its edges (Liu et al. 2023, Lost in the Middle, TACL 2024): the longer the accumulated instructions grow, the less each one is actually used, so each added rule dilutes the ones before it.

System prompts aren't enough for AI systems that are supposed to act like someone within a role: more instructions don't solve the statelessness underneath that is causing AI to be unaware of the situation or itself.

To steer interactions to how they should feel and where they should go, we need to give the AI a continuous sense of what is going on and who it is.

The solution needs to fit within the stack you already have and know could work. Your model, weights, tools, and skills stay, only the trial-and-error patched system prompt goes. We steer using a harness that plugs between the user and the model to interpret inputs with the situation and design in mind and to check outputs. Emulating a world model as we laid out here: AI needs to understand the world of human interactivity.

Per turn, the harness does three things. It keeps an awareness of the interaction state. It holds the behavior you designed, who your system is. And it injects only the per-turn relevant pieces of both into the model. Then come two more: it measures the result, and over time it improves itself from what it measured. The rest of this page walks through those five parts in order.

where the harness sits in your stack

We give the AI a situational awareness by tracking the interaction states in full. Most drift happens as conversations go on: that statelessness lets the situation slip, until the system is answering a conversation it is no longer in. An interaction state is what a conversation actually consists of: the type of situation this is, the goal the two sides share, which part of the conversation we are in and what subpart of that, who has done what so far, what the tools have done and are doing, what we assume the other wants or expects, the environment the exchange sits in, how the moods have shifted along the way, and other things a person would track without noticing.

The harness observes and records that state, updates it every turn, and checks and corrects it along the way. Each turn adds to the record, so the understanding grows as the conversation does. Turn two hundred reads from the record as clearly as turn two. In production, Sight is where you see it.

To react appropriately to the interaction state, we design who the system is supposed to react as. The design runs three levels deep. Identity is who the system is with multiple facets that give it a depth and logical responses in different situations. The role is what it is there to do, divided into subroles and their tasks. The history is what it has done and been, with this user across sessions, the past it stays consistent with. The result is a consistent, coherent experience, and a role filled effectively.

The state and the design together hold far more than any reply needs, so injection is a selection: enough of the situation to understand the incoming message, enough of the self to answer it in character, assembled fresh and small every turn. The model already receives the flow of the conversation; what it lacks is the compressed idea of it. Each response comes out coherent, because the model knows what this moment follows; predictable, because it reacts as designed; natural, because it improvises from an understanding instead of reciting instructions.4Sierra's τ²-bench airline (Barres et al. 2025): injecting the runtime interaction state lifts GPT-5.2 from 56.0 to 74.0 pass^4, with no change to the weights. Submission rules required a byte-identical system prompt, so one of the harness's three per-turn mechanisms was disabled; the lift came from the other two. (See how we do the context engineering.)

two streams, one injection

After the reply, the harness measures what the turn actually did. It updates the interpretation: feeding back into the awareness. It catches wrong outputs that need rerunning: a response that breaks the design or the flow of the conversation can be caught and redone before it costs the interaction. And it saves: the turn, its state, and its result persist as a record.

every turn lands on every measurement

After a conversation has run its course and we know the outcome, the harness can self-improve. It reflects on the interaction and tries to spot places where it went wrong or where it could have done even better. With the saved states and trajectory, it changes some of the design, some of the injection mechanics, or even some of the way it calls tools, to check whether those breakages and weaknesses go away. If a tweak solves the problem, it attempts the solution on known successful interactions to make sure it is not overfitting or breaking other things. Learnings like this allow the steering to self-improve and to share what it learned across sessions, deployments, and even industries.5The mechanism family is proven, separately from our product: agents improve by reflecting on their own transcripts and storing the lessons, with no weight updates (Shinn et al. 2023, Reflexion, NeurIPS 2023); iterative self-critique lifts output quality across tasks (Madaan et al. 2023, Self-Refine, NeurIPS 2023); and reflective prompt evolution can outperform reinforcement learning while touching no weights (Agrawal et al. 2025, GEPA). These ground the approach; the verify-on-known-good step and cross-deployment sharing are ours.

The compass is your KPIs; the result is month six running better than month one, on the same model. The breakage seen along the way becomes benchmarks and the next generation of interaction systems: the field.