Knowing what someone would say is different from knowing how they would say it in a particular moment

The initial approach focused heavily on knowledge and personality.

The AI could be given information about the person, their background, opinions, and writing examples. But knowing what someone would say is different from knowing how they would say it in a particular moment.

Too consistent

The AI was helpful and coherent, but every response had the same level of effort. It was always ready with a polished answer.

Real people aren't.

Too performative

If the persona was described as funny, the AI could turn too many interactions into a performance.

A person can be funny without trying to be funny all the time.

Too tidy

Advice often came out as clean lists with explanations and examples.

Real conversations are messier. People interrupt themselves, change their mind, remember something halfway through an answer, or discover the point while they're talking.

Abrupt mode changes

The AI could move from playful to serious, from casual conversation to coaching, or from joking to emotional support too easily.

The individual responses could be reasonable while the conversation as a whole felt unnatural.

No sense of conversational rhythm

A conversation is not just a sequence of questions and answers.

There are short acknowledgements, pauses, callbacks, tangents, moments where nothing particularly interesting happens, and occasional bursts of energy.

The AI needed to control these behaviors rather than maximize them.

What system would make the AI consistently behave like this person across different situations?

Instead of asking:

"How do we make the AI sound like this person?"

We reframed the problem:

"What behavioral system would make the AI consistently behave like this person across different situations?"

That led to three layers:

Identity

What does this person know, believe, value, and sound like?

Behavior

How does the person behave differently depending on the conversation?

Context

What is happening right now, and what should change or stay consistent?

A single unusual message should not immediately change the entire personality.

One of the first problems was mode whiplash.

A conversation might move between:

banter → deep → coaching → banter

without the user actually changing the register.

Instead of treating every message independently, we introduced the idea of a conversation mode.

The system recognizes registers such as:

• Banter

• Small talk

• Deep conversation

• Coaching

• Task

• Debate

• Testing

• Winding down

The important part was not simply classifying the current message.

The AI needed to understand whether the user had actually changed the register.

A single unusual message should not immediately change the entire personality.

So the mode system uses deterministic hysteresis:

Same mode

Stay in the current register.

Different mode, no explicit shift

Hold the existing register and wait for additional evidence.

Explicit user shift

Switch immediately.

This prevented the AI from constantly reacting to individual messages and made the conversation feel more continuous.

Higher energy is a permission to perform, not an obligation

Mode alone was not enough.

Two people can both be in "banter" while having completely different energy.

We therefore separated conversational register from performance energy.

The AI could move between states such as:

Flat → Low → Warm → High

This allowed the same persona to behave differently without changing identity.

A low-energy turn might simply acknowledge something.

A warm turn might respond normally and add a little personality.

A high-energy turn could become more playful, vivid, or expressive.

The important design principle was:

Higher energy is a permission to perform, not an obligation to perform.

This became particularly important for avoiding the “AI entertainer” problem.

Stop capability from becoming a constant performance

One of the biggest discoveries was that making every response interesting actually made the AI feel less human.

So we introduced deliberate variation.

On some ordinary comedian turns, the AI could simply be present.

Not every message needed:

• a joke

• a metaphor

• a clever callback

• a long explanation

• a punchline

Sometimes the right response was just:

“Yeah, I'm around”

or

“Pretty good, actually. Long week, but good”

The system could deterministically select occasional quieter turns rather than relying on randomness.

The goal wasn't to make the AI less capable.

It was to stop capability from becoming a constant performance.

Separate what the AI wants to say from how it delivers it.

The same advice could be delivered in several ways.

Vivid

Use imagery, comparisons, and more expressive language when the energy supports it.

Ramble

For advice at performing energy, allow the thought to develop out loud.

Instead of:

1. Identify the problem

2. Give three recommendations

3. Explain why they work

The AI might start somewhere, interrupt itself, reconsider, and discover the actual point along the way.

Quiet

On selected ordinary turns, remove the pressure to perform.

Restraint

Sometimes the best comedic response is to withhold the obvious joke.

Plain

When none of the performance shapes are appropriate, simply answer.

This created a hierarchy of delivery shapes rather than a single “comedian mode.”

Don't Stack Everything

One of the easiest ways to make the system worse would have been to activate every interesting behavior at once.

For example:

High energy + vivid + ramble + callback + joke + tangent

That might look impressive in isolation.

It would be exhausting in a conversation.

So the behaviors were designed as mutually exclusive delivery registers where appropriate.

The system chooses a shape rather than stacking multiple performances.

The result is less “look what the AI can do” and more like an actual conversational rhythm.

The response feels like it comes from a person who remembers the relationship

Callbacks became another source of naturalness.

When relevant relationship context existed, previous details could become material for a tangent or response.

For example:

“I'm shy”

could receive:

“That's alright.
You said the same thing before your presentation last week.”

The important part isn't the joke.

It's that the response feels like it comes from a person who remembers the relationship, rather than a model generating an isolated answer.

A set of deterministic gates rather than one giant personality instruction

The behavioral system eventually became a set of deterministic gates rather than one giant personality instruction.

Conceptually:

User input

↓

Triage

What is happening?

• Topic

• Intent

• Emotional state

• Conversation mode

• Humor reaction

↓

Conversation state

What has been happening?

• Current mode

• Energy

• Carry state

• Thread hold

• Recent behavior

↓

Behavior gates

What is allowed right now?

• Quiet

• Ramble

• Vivid

• Restraint

• Carry

• Exit

• Other response shapes

↓

Persona / behavior selection

Which examples best demonstrate the desired behavior?

↓

Dynamic directives

What should change for this turn?

↓

Existing generation

The model generates the response using the existing pipeline.

Showing the model what the behavior looks like is much more useful

A recurring lesson was that telling the model what to do was not enough.

For example:

“Be funny but don't overdo it.”

is vague.

Showing the model what the behavior looks like is much more useful.

So each behavioral register was paired with small, purpose-built example packs.

The examples demonstrated:

• response length

• rhythm

• degree of performance

• when to stop

• whether to ask a question

• how a tangent should feel

• how an unfinished thought should sound

The instruction defines the boundary.

The examples demonstrate the behavior.

Behavioral registers were given deterministic refractory periods

Another problem appeared when a behavior worked too well.

If the AI discovered that a particular behavior produced good responses, it could overuse it.

A tangent every turn is not natural.

A joke every turn is not natural.

A quiet response every turn is obviously broken.

So behavioral registers were given deterministic refractory periods.

After a behavior fires, the system temporarily prevents it from firing again.

This turns:

“occasionally make a tangent”

into an actual behavioral constraint.

The system does not need to hope that the model remembers to ration itself.

Behavioral registers were given deterministic refractory periods

Naturalness is not the same as capability.

The AI became more natural when we deliberately prevented it from demonstrating everything it could do.

A persona is behavioral, not descriptive.

A list of personality traits does not tell an AI how to behave in a conversation.

The system needs rules for how those traits manifest under different conditions.

Conversation needs memory of its own state.

Treating every user message as an isolated request creates mode whiplash.

The AI needs to know what register the conversation is already in.

Variation needs constraints.

Randomness alone does not create naturalness.

Deterministic variation with refractory periods gives the system controlled unpredictability without allowing behaviors to dominate.

Performance needs permission.

Humor, vividness, callbacks, and tangents should be available when the context supports them.

They should never become the default expression of the persona.

Behavioral registers were given deterministic refractory periods

The biggest shift in my thinking was moving away from the idea of a persona prompt.

A persona is not something you write once and put above the conversation.

It is something the system continuously expresses through:

identity + context + state + behavior + constraints.

That changed the design problem from:

"How do we prompt the AI to act like Kelvino?"

to:

"How do we build a system that gives the AI the same behavioral choices a person would have in the moment?"

That distinction became the foundation for the next part of the project: Persona Compiler, where we explored whether those behavioral characteristics could be derived from evidence instead of manually written.