What comes after ‘user’ and ‘assistant’?
User and assistant are learned interaction roles, not laws of AI. What changes when specialised models are trained around the actors, claims, evidence and actions of the worlds they serve?
By Rico Solo
Every conversation you have with ChatGPT, Claude or Gemini is built around a surprisingly simple idea:
There is a user. And there is an assistant.
You say something. The assistant responds. You say something else. The assistant responds again.
It feels so natural that it is easy to assume this is simply how large language models work.
It isn’t.
“User” and “assistant” are an interaction model we created. And as AI moves beyond chat and into increasingly specialised systems, I’m beginning to wonder whether we’ve accidentally started treating that model as a law of nature.
What happens if we teach AI a different one?
Chat is really just structured text
Underneath the interface, a language model fundamentally operates on sequences of tokens. It does not intrinsically understand that one person is a “user” and another is an “assistant”.
Instead, chat models are trained using formats that distinguish different parts of a conversation.
Conceptually, something like:
SYSTEM
You are a helpful assistant.
USER
What's the capital of France?
ASSISTANT
Paris.
Different models encode this differently. Some use special control tokens around each message. Others use different templates. But the principle is the same.
As Hugging Face’s documentation explains, language models ultimately operate on token sequences, while conversational roles are represented through formatting and control tokens.
And once a model has been trained using a particular format, that format matters. Using the wrong chat template can degrade performance because you are moving away from the interaction patterns the model learned during training.
In other words:
The interaction protocol becomes part of what the model learns.
That is where things get interesting.
We’ve already added a new role: tools
Modern AI models increasingly do something other than talk.
They act.
Ask an AI for today’s weather and the interaction might conceptually become:
USER
What's the weather in Brisbane?
ASSISTANT → WEATHER TOOL
location="Brisbane"
TOOL
27°C, sunny
ASSISTANT
It's 27°C and sunny.
That TOOL interaction is important.
We have effectively expanded:
into:
And models can be specifically trained to become better at this.
Google’s FunctionGemma is an interesting example. It is a small model specialised for function calling, designed to translate natural-language requests into executable software actions.
Google also encourages developers to fine-tune FunctionGemma for their own APIs, schemas and workflows.
There is an important distinction here between teaching a model how to call a tool and teaching it when and why a particular tool should be used.
On Google’s Mobile Actions evaluation, further fine-tuning improved FunctionGemma’s accuracy by 47% over the base model.
So we already know something important:
A model can become better at operating inside a particular environment when its training reflects that environment.
And I suspect this becomes much more important over the next few years.
As model training and fine-tuning become cheaper, easier and more widely available, particularly inside large organisations, I expect post-training to become increasingly common around specific core business processes.
An insurer may train around claims. A bank around lending and financial operations. A hospital around clinical workflows. A logistics company around supply chains.
Not necessarily by training entirely new foundation models, but by taking capable general models and teaching them the interaction patterns, roles, tools and constraints of a particular environment.
Which raises another question.
Why should tools be the only new roles we teach them?
What does the model learn to expect?
The underlying model can stay the same while post-training changes the structure of the interaction it learns to navigate.
A sequence of tokens to continue
The model receives one continuous sequence. It learns patterns in the text, but the sequence contains no inherent idea of a requester, an assistant or an executable capability.
No inherent roles or tools
If post-training can teach a model to expect users, assistants and tools, what happens when we train it to expect the actual actors in the environment it operates within?
The model architecture may stay the same. The interaction protocol it learns does not.
What if the people became native too?
Imagine an AI system designed for family law.
A typical AI interaction today might look like:
USER
My former partner won't let me see my children.
ASSISTANT
...
But that is not really the world the AI is reasoning about.
The actual environment might contain:
Each participant sees the situation differently.
One parent might make a claim. The other might dispute it. A child might express a preference. A psychologist might provide a professional opinion. A text message might provide evidence. A court order might establish something legally.
Yet we often flatten all of this into context for an assistant.
What if we did not?
Imagine post-training a specialised model on interactions structured more like:
<PARENT_A>
I haven't seen the children for three weeks.
</PARENT_A>
<PARENT_B>
They cancelled the previous two visits.
</PARENT_B>
<CHILD_A>
I want to see both parents.
</CHILD_A>
<COURT>
Current parenting order...
</COURT>
<ASSISTANT>
...
</ASSISTANT>
The tags themselves are not the interesting part.
The interesting part is what a model might learn from enough examples structured this way.
Instead of its default interaction model being:
A user is telling me something.
it could become something closer to:
I am observing several actors who each possess a partial perspective on a shared situation.
That changes more than speaker identification.
If Parent A says:
“Parent B is deliberately stopping me seeing the children.”
the system should not necessarily flatten it into a fact. It might instead preserve the source and status of the statement:
Parent B is preventing contact.
- Source
- Parent A
- Type
- Claim
- Subject
- Parent B
- Status
- Not independently established
The source of the statement changes what the statement is.
In areas such as law, healthcare, insurance, government and investigations, that distinction can matter enormously.
Pieces of this are already happening
This is not entirely hypothetical.
Researchers have been experimenting with systems containing multiple roles for several years.
In 2023, CAMEL demonstrated role-playing between AI agents, allowing agents with different assigned roles to cooperate on tasks.
MetaGPT went further by modelling something resembling a software company. Agents can take roles such as product manager, architect, engineer and QA, with work passed between them using defined standard operating procedures.
Stanford’s Generative Agents research placed 25 AI agents inside a simulated town. They remembered experiences, formed plans, developed relationships and shared information. Starting with one agent wanting to organise a Valentine’s Day party, invitations spread through the community and agents eventually coordinated to attend.
Google DeepMind’s Concordia goes further towards modelling an environment. It represents entities acting inside simulated physical, social or digital worlds, with a “Game Master” resolving their actions and updating the environment.
But these are not quite what I am proposing.
Most create specialised roles around a general-purpose model using prompts, orchestration and software.
The interesting next step would be making some of those distinctions part of the model’s post-training itself.
From role-playing to role-native AI
Imagine a healthcare model whose learned interaction world is not:
but:
Or workers’ compensation:
And then combine those roles with native actions:
Now the model is not simply being taught how to call an API.
It is being taught something about how work happens inside that environment.
It might learn that a doctor’s assessment means something different from an employer’s preference.
That a worker’s statement is a first-person account rather than an independently established fact.
That some information can be disputed without either account being discarded.
That particular actions require particular evidence.
That certain decisions require another actor’s authority.
This would require more than renaming message roles.
The post-training data would need to consistently preserve things such as who is speaking, their relationship to the situation, the type of information they are providing, what authority they have and how those distinctions affect subsequent actions.
Over enough examples, role could potentially become more than metadata.
It could become part of the model’s learned representation of the task.
At that point, we are not really prompting an assistant anymore.
We are training an operator.
And perhaps chat is not the whole environment
There is a related implication here.
A legal case is not a conversation.
Neither is a medical history, an insurance claim, a construction project or a company.
They contain:
If specialised models begin distinguishing between actors, claims, evidence and authority, conversation history may eventually become too weak a representation of the environment itself.
Chat could remain one way information enters the system, while a more persistent representation holds what is currently known, where it came from and what remains disputed or unknown.
That is a separate architectural question, but it follows naturally from the same idea.
Once we stop assuming every interaction consists of one “user”, richer representations become possible.
User and assistant were the beginning
USER → ASSISTANT is an incredibly effective abstraction.
It helped turn strange text-prediction machines into products hundreds of millions of people could immediately understand.
But it is not a law of AI.
We have already taught models to expect system instructions, tools, retrieval and increasingly complex agent environments.
And if post-training becomes cheap enough that organisations routinely specialise models around their own workflows, the interaction structure itself may become an important part of that specialisation.
A claims model might learn the world of claims.
A healthcare model might learn the relationships between patients, carers and clinicians.
A legal model might learn to preserve the distinction between an allegation, evidence and an established decision.
The underlying model architecture may not need to change.
What changes is the interaction model we teach it.
And perhaps the best specialised AI will not simply be the one with the biggest model or longest context window.
It may be the one whose learned interaction model most closely resembles the environment it is expected to operate in.
This article grew from a conversation with Henk Dijkstra. It reflects ideas we explored together, distilled here through my own perspective.