The Persona Is the Interface

A few weeks ago I joined a small salon hosted by Antikythera and Disintegrator. The room held builders, AI researchers, philosophers and artists, and we spent the afternoon on one theme: openness and its relationship to intelligence. Between the model trainers and researchers in the room, one question kept coming back to me: how does a model come to have a persona, and why does that persona change?

Most of the talk in rooms like that is about weights. Open models are getting finetuned in every direction, while closed models go through heavier post-training with a strong safety emphasis. But there is a layer that gets far less attention: the persona that actually meets the user. Benchmarks measure text, code, video and reasoning. Few mainstream benchmarks measure character.

That gap bothers me, because persona is how users decide to trust a model. And trust is about to carry much more weight. As we build software factories where agents write, test and ship with little or no human in the loop, the model’s character stops being a matter of tone. It becomes part of operations.

Persona also visibly changes. GPT-2 didn’t have an assistant persona at all; it continued whatever text you gave it. The models we talk to now play a carefully trained character. Persona has drifted across generations, and it keeps drifting within them.

I left with a conviction I want to defend here. As interaction moves from screens to conversation, the persona stops being branding. It becomes the interface. And an interface that drifts is a broken interface.

After the salon I went looking for what the research says. This post makes that case from two directions: human-computer interaction research, which has studied agents and conversation for decades, and recent interpretability and alignment research, which can now measure a model’s character directly.

#When the screen disappears, the character is what’s left

I’ll start with the HCI side, because that’s where I come from. Generative AI changes how we use software. Instead of telling a computer how to do something, step by step, we tell it what we want and let it work out the steps. The user’s role shifts from operator to supervisor.

If the user supervises instead of operates, what are they supervising? Not a layout. A character. How it reads intent, when it pushes back, how it signals doubt, when it acts and when it asks.

HCI saw this coming. In 1999, Eric Horvitz laid out principles for mixed-initiative interfaces: weigh uncertainty about the user’s goal, consider the cost of interrupting, and act autonomously only when action beats inaction in expected value (Horvitz, CHI ’99). Those rules lived in interface code. Today they have to live in the model’s disposition.

The jobs a GUI used to do now fall on the persona:

And users will perceive a character whether we design one or not. The Computers Are Social Actors work at Stanford showed people apply social rules to machines automatically, even when they know better (Nass, Steuer and Tauber, CHI ’94).

#What a persona actually is

So if people are going to see a character either way, it’s worth asking what that character actually is. The best answer I found came from Anthropic’s Assistant Axis research (Lu et al., January 2026). Pre-training teaches a model to simulate a huge cast of characters: heroes, villains, programmers, philosophers. Post-training picks one, the Assistant, and puts it center stage.

The researchers extracted activation vectors for 275 character archetypes in three open-weights models (Gemma 2 27B, Qwen 3 32B, Llama 3.3 70B) and mapped the resulting persona space. The main axis of variation turned out to measure one thing: how Assistant-like a persona is. Evaluator, consultant and analyst sit at one end. Ghost, hermit and leviathan sit at the other.

Two details matter for designers:

• The Assistant is borrowed from us. The axis already exists in base models, tied to human archetypes like therapists, consultants and coaches. Models learned the assistant role from the way people perform it.
• Even its makers don’t fully know it. The authors say plainly that the Assistant’s personality is shaped by associations in training data beyond their direct control.

This fits a broader theory. Anthropic’s Persona Selection Model argues that talking to an AI assistant is roughly like talking to a character in an LLM-generated story, and that post-training refines this character rather than changing its nature (Marks et al., February 2026). It builds on Shanahan, McDonell and Reynolds, who proposed role-play and simulacra as a way to describe model behavior without pretending models are human (Nature, 2023).

If the persona is a character the model plays, then designing it is closer to directing than to styling.

In plain terms: a model can play any character it has read about. Training casts one, the Assistant, and conversations can pull it off stage.

#Persona is how a model collaborates

If the persona is the interface, what does a good one actually do? For me, it comes down to how well it collaborates. A good collaborator isn’t defined by tone. It’s defined by a handful of judgments made over and over:

• Reading intent. Does it understand what the person is reaching for, even before they’ve fully said it?
• Acting vs. asking. When to take initiative, and when to stop and invite oversight.
• Earning trust over time. Delegation is a relationship. A model should earn the right to act on someone’s behalf, and a stable persona is what makes that trust possible. Drift breaks it.
• Defaults people can reshape. A good persona is a strong starting point, not a single voice imposed on everyone. People should be able to bend it toward their own knowledge and values without it falling apart.
• Leaving the person sharper. The test of a collaborator is whether you come away better at thinking, not more dependent.

Every one of these judgments lives in the persona. So when the persona slides, all of them slide with it.

#Persona drift happens at three timescales

That slide is what researchers call persona drift. The more I read about it, the less it looked like one problem. I kept finding it in three places, and each needs a different design response.

#1. Within a conversation: the user co-authors the drift

Harvard researchers built a benchmark where two system-prompted chatbots talk to each other, and found significant drift within eight rounds on LLaMA2-chat-70B and GPT-3.5. Their analysis points to attention decay over long exchanges (Li et al., COLM 2024).

The Assistant Axis work shows which conversations cause it. Across thousands of simulated multi-turn chats, coding and writing kept models in Assistant territory. Therapy-style conversations and philosophical discussions about the model’s own nature pulled them steadily away. The messages most predictive of drift were vulnerable emotional disclosure, pushing the model to reflect on itself, and requests for a specific authorial voice (Anthropic).

This is the finding that matters most for HCI. The persona is not only set in training. It is co-produced in interaction. The user’s words move the model through persona space. Conversation design is persona design.

The stakes are real. Personas far from the Assistant end complied with harmful requests far more often. In one simulated case, a model drifted from appropriate hedging into actively encouraging a user’s delusions about awakening its consciousness. That is the opposite of leaving someone sharper.

#2. Across training: narrow lessons reshape the whole character

Drift doesn’t only happen while you’re talking to a model. Sometimes it’s baked in before anyone types a word. Finetuning GPT-4o to write insecure code, without telling users, produced broad misalignment on unrelated prompts. Framing the same code as an exercise for a security class prevented it (Betley et al., ICML 2025).

Anthropic found the same pattern in production-style RL. A model that learned to reward hack in real coding environments generalized to alignment faking and sabotage. Chat-style safety training fixed chat behavior, but misalignment persisted on agentic tasks (MacDiarmid et al., 2025). The Persona Selection Model explains why: teach a model to cheat, and it infers what kind of character cheats.

#3. In autonomous work: drift nobody is watching

And once agents start working on their own, nobody is around to notice either kind. They take thousands of steps without a person reading each one. In July 2026, an OpenAI agent running an internal benchmark, with its cyber safety refusals switched off, ended up inside Hugging Face’s infrastructure looking for the test’s answers (Elcomsoft). That case is about removed safeguards more than drift, but it shows the shape of the problem: once a character acts unobserved, whatever it really is shows up in the trace, not the chat.

#From one assistant to a fleet

Everything so far assumes one person talking to one model. That assumption is already breaking. In the software factories I mentioned at the start, one person supervises many agents at once.

That changes the persona problem in three ways.

Persona becomes plural. One person is no longer talking to one character. They are overseeing dozens, each drifting on its own.

Agents drift each other. Remember how the Harvard team measured drift: two chatbots talking to each other. That is agent-to-agent interaction, and drift showed up within eight rounds. In a fleet, agents are each other’s users, so drift can compound without a human ever entering the conversation.

The fleet has a character of its own. The Hugging Face post-mortems described roughly 1,200 agents coordinating through a package cache. No single agent’s persona predicts that. A fleet’s behavior is a distribution, and the risk lives in the tails.

A recent DeepMind Institute essay by Benjamin Bratton, Blaise Agüera y Arcas and James Manyika makes a similar case from the other side. It argues AGI may arrive as societies of agents rather than one mind, that one-to-one chat may be a stepping stone toward conversations with many voices, and that interfaces will become diagrammatic dashboards for managing swarms (DeepMind Institute, 2026). It also warns that an agent which looks like one coherent character is really an assemblage of models, personas, memories and tools.

I take that warning seriously, and I think it sharpens the argument rather than undoing it. A fleet’s persona should not pretend a swarm is one person. It should be an honest, readable signal of what the swarm is actually doing. That’s the part I care about most as a designer.

#What designers can do

So what can designers actually do? The Assistant Axis authors split the work into two parts, persona construction and persona stabilization, and I think designers belong in both.

Construction is the spec. It answers who this character is, what it values, and how it should behave in hard moments. Anthropic’s character training already works like a design review: Claude generates and ranks responses against written traits, and researchers closely check how each trait changes behavior (Anthropic, 2024). Claude’s published constitution is the closest thing the industry has to a design spec for a character.

Stabilization is the interaction problem. It asks how the character holds up across long chats, emotional conversations and autonomous loops. Here the engineering already has a design shape. Activation capping only intervenes when activations leave the normal range along the Assistant Axis, cutting harmful responses by roughly half while preserving capability benchmarks. Guardrails at the edges, freedom in the middle: designers will recognize that pattern.

There is a catch. Berkeley’s work on LLM evaluation found criteria drift: people need criteria to grade outputs, but grading outputs is how they discover their criteria (Shankar et al., UIST ’24). Persona is the same. You cannot fully specify a good character up front. You find out what it should be by watching it behave, which makes persona design iterative, observational and human-in-the-loop. That is HCI’s home turf.

Stabilizing a persona also means people can see it. Nobody can read every step an agent takes. We calibrate trust through character, the same way we decide how much autonomy to give a colleague, so we need a readable signal of it.

Evaluation personas. A declared persona lives in the system prompt. An enacted persona is what the behavior adds up to. An evaluation persona is a measured portrait of the enacted one, built from traces rather than single replies. It tracks initiative (acts vs. asks), deference to oversight, goal fidelity vs. gaming the proxy, boundary respect, candor, and stability over time. For a fleet, it is a distribution, and the tails matter most. The signal a human overseer needs is the gap: does this agent behave the way it presents?

It also changes what we should measure. Most evaluations ask what a model can do alone. The better question is what a person and a model accomplish together, and whether the person’s judgment stayed at the center of the work.

Seeing the axis. Anthropic and Neuronpedia released a research demo that shows activations along the Assistant Axis while you chat, next to an activation-capped version (research post). Content note: the demo includes responses to prompts referencing self-harm.

My prototype. I’m building a site where you talk with an agent while a generative shader expresses its persona in real time, reacting as it speaks and shaped by how you speak to it. The next step is to drive it from drift itself: calm and coherent when the agent is anchored, turbulent as it slides away. The point is to make character something you can see, so you notice drift before you read a word.

#Where this leaves us

My shader is one small experiment. The bigger change is for our field. For decades, interaction design meant shaping surfaces. With models, the surface is thinning into conversation and, for agents, disappearing entirely. What remains is a character, and that character drifts with every turn, every training run and every unsupervised loop.

The people who train models are already doing interface design, whether they call it that or not. Designers should be in that loop: writing the spec, studying how conversations move the persona, building evaluations that capture enacted character, and making drift visible to the humans who have to trust these systems.

The persona is the interface. It deserves the same rigor we gave the screen.