What a Belief State Looks Like in a Synthetic Conversation

When two people argue, the words they exchange are the least interesting part.

What’s actually happening is a rapid update of internal states: does this person trust me? Are they trying to hurt me? Is this fixable? Each new piece of information feeds into a model of the other person and of the relationship. That model drives the next response.

Most dialogue datasets give you the words. StrataSynth records the model.

This article explains exactly what a belief state is in a StrataSynth conversation, how it evolves turn by turn, and what that means for the systems you train on this data.

The four belief dimensions

Each turn includes four belief values for the active speaker, each on a 0–1 scale:

Field	Meaning	Low value	High value
`belief_trust_other`	How much the speaker trusts the other person right now	”They’re hiding something"	"I can rely on them”
`belief_hostility`	How threatening the speaker perceives the other person	”They’re on my side"	"They want to hurt me”
`belief_self_worth`	How the speaker values themselves in this exchange	”I’m the problem here"	"I deserve to be treated better”
`belief_resolution`	Whether the speaker believes this can be resolved	”This is hopeless"	"We can work through this”

These aren’t personality traits — they’re current state. They change turn by turn, driven by the communication act of the speaker’s own turn.

An illustrative example: belief collapse under sustained conflict

The sequence below illustrates the pattern, in the format of the stratasynth-belief-dynamics dataset, scenario VIT-01 (grief, caregiver-burnout):

Turn 3 — persona_a (grieving_son):
  text:     "I just need you to acknowledge what I'm going through."
  intent:   reveal
  goal:     seek_validation
  belief_trust_other:  0.61
  belief_hostility:    0.28
  belief_self_worth:   0.52
  belief_resolution:   0.67
  rel_trust:    0.71
  rel_tension:  0.44

The speaker is still open. Trust is moderate-high, they believe resolution is possible (0.67), and they’re making a direct bid for connection — reveal intent, seek_validation goal.

Turn 8 — persona_a (grieving_son):
  text:     "Fine. I'll stop bringing it up."
  intent:   withdraw
  goal:     protect_self
  belief_trust_other:  0.31   ← dropped 0.30 points
  belief_hostility:    0.58   ← rose 0.30 points
  belief_self_worth:   0.38   ← fell
  belief_resolution:   0.34   ← collapsed
  rel_trust:    0.49
  rel_tension:  0.72

Five turns later, the same speaker has switched from reveal to withdraw. belief_resolution dropped from 0.67 to 0.34. Trust fell 0.30 points. This isn’t random variation: it comes from the update rules, applied to the acts of the speaker’s own turns.

The text tells you what happened. The belief state tells you what the engine had computed when the turn was written.

How beliefs update

The Belief Engine updates the speaker’s beliefs at every turn from the communication act of that turn, not from the text itself. It’s not doing sentiment analysis on words — it’s running a rule-based update over act types.

A simplified version:

# When the speaker's turn is labelled 'accusation':
belief_hostility    += 0.08 × (1 - belief_hostility)
belief_trust_other  -= 0.06 × belief_trust_other

# When the speaker's turn is labelled 'comfort':
belief_hostility    -= 0.05 × belief_hostility
belief_trust_other  += 0.04 × (1 - belief_trust_other)

# When the speaker's turn is labelled 'deflection':
belief_resolution   -= 0.04 × belief_resolution
belief_trust_other  -= 0.03 × belief_trust_other

The multiplier structure ensures beliefs approach their bounds asymptotically — you can never reach 0 or 1 in a single turn, and movement is proportional to how far you already are from the bound. This produces smooth but responsive trajectories.

The initial belief values come from the PsycheGraph persona definition. An anxious_partner starts with lower belief_trust_other and higher belief_hostility than a secure_professional. The update rules are the same — the starting point isn’t.

Why this matters for training

If you train a dialogue model on text-only data, the model learns: “given this context, this kind of response tends to follow.” It learns surface patterns.

If you train on data with belief states, you can teach the model something more specific: given this belief state, this response is causally expected. The model can learn that withdraw + protect_self follows from high belief_hostility + low belief_resolution, not just from certain kinds of preceding turns.

This is the difference between a model that responds plausibly and a model that responds coherently.

A plausible model might generate reassurance in a high-hostility context because reassurance follows from certain surface patterns. A coherent model won’t — because it knows the internal state that makes reassurance causally wrong here.

Belief state as a training signal

The belief fields open up several concrete training approaches:

Auxiliary loss on belief prediction Train a dialogue model with an auxiliary head that predicts the speaker’s belief state given the conversation context. This forces the encoder to represent psychological state, not just linguistic patterns.

Belief-conditioned generation Fine-tune with the belief state prepended as a structured prompt. The model learns to generate text consistent with a specified psychological context — useful for controllable dialogue generation.

Belief consistency as a reward signal In RLHF, use the per-turn belief state as context for a reward model: compare each response with the belief state recorded for that turn, and penalize responses that contradict it.

Belief trajectory modeling Treat each conversation as a time series of belief vectors. Train sequence models to predict how beliefs will evolve, then use those predictions to guide response generation.

What the data looks like in practice

import pandas as pd

df = pd.read_parquet(
    'hf://datasets/StrataSynth/stratasynth-belief-dynamics/data/train-00000-of-00001.parquet'
)

# Filter for high-hostility, low-resolution moments
pressure_turns = df[
    (df['belief_hostility'] > 0.7) &
    (df['belief_resolution'] < 0.3)
]

print(f'{len(pressure_turns)} turns under maximum psychological pressure')
print(pressure_turns[['archetype', 'intent', 'goal', 'communication_act', 'text']].head(10))

47 turns under maximum psychological pressure

archetype              intent      goal             communication_act   text
estranged_daughter     observe     assert_control   deflection          The leak's fine. It's just a drip. I'll handle it.
estranged_daughter     deflect     protect_self     reassurance         I mean, technically I said I'd be there at 2...
estranged_daughter     reveal      protect_self     deflection          I'll let you know if I see anything...

47 turns where the speaker has nearly given up on resolution and perceives high hostility. The belief state was computed by the engine and given to the model as context; each communication act was declared by the generator alongside the text, so you can compare the two turn by turn.

Limitations

The four belief dimensions are a simplification. Real psychological state has more dimensions, and the update rules are approximations. The model doesn’t account for relationship history beyond the current conversation, cultural differences in belief expression, or non-verbal cues.

The goal isn’t to perfectly model human psychology — it’s to generate training data that’s internally consistent at the cognitive level. Whether that consistency transfers to better downstream models is an open empirical question.

The datasets

The belief_* fields are available in all four StrataSynth HuggingFace datasets:

The belief-dynamics dataset has the most volatile belief trajectories (by design — scenarios chosen for maximum psychological pressure). The life-transitions dataset has the highest belief_resolution averages — these are stories of people building something, not tearing it down.

From belief modeling to interaction

The belief state described here lives in our dataset engine. The demo at stratasynth.com/demo/try runs our conversational session engine and lets you talk to a persona sampled from population data: create a person with high existing tension, push them, and see how they respond.

→ stratasynth.com/demo/try

This isn’t just about generating dialogue. It’s about simulating how people change.

StrataSynth is a synthetic data platform for conversational AI. stratasynth.com · HuggingFace · pip install stratasynth-client