method
What's under the hood.
Most behavioral tools ask you to trust a black box. Here's how this one is built: the model, the pipeline, the principles, and the guardrails that make the readout something you can stake a decision on.
the model
People don't sit on a scale from 1 to 10. They sit in a state.
A satisfaction score collapses a person into a number and loses the thing that matters: where they are in their relationship with you, and which way they're about to move. dfmchn · Difference Machine models a population as a closed system of five behavioral states, connected by a limited set of valid transitions. Movement is constrained. You don't leap from contentment to open hostility without passing through the evaluation in between, because people don't either.
- passive_inertia
- on autopilot. Satisfied, unengaged, renewing or participating without re-examining the choice. (a customer who never reviews the bill; a voter who always votes the same way; an employee coasting.)
- active_audit
- re-evaluating. Something disrupted autopilot. The population is actively weighing value against friction. This is the central hub: almost every transition passes through it.
- value_insulated
- locked in. Wants out but can't leave, held by a contract, a switching cost, a lack of alternatives, or dependency. Dissatisfied, but stuck. (a long contract; no viable opposition; nowhere else to get care.)
- active_fluid_churn
- in and out. Leaves and returns intermittently, driven by promotions, seasons, mood, or circumstance. Unstable, not lost.
- terminal_adversarial
- actively against. Not just gone, but working against you: advocating others leave, organizing, going public.
The states are linked by seven valid transitions. When pressure hits, a population moves from passive_inertia into active_audit; from there it can resolve and fall back to autopilot, get trapped in value_insulated, or exit into active_fluid_churn. Mapping those transitions is how the system spots decay long before anyone formally leaves.
the pipeline
Seven stages, from a pile of comments to a model you can fly.
- 01
Ingest.
Pull a corpus of human text from its source, stored in monthly compressed archives so each slice can be verified independently and collection resumes cleanly after any interruption.
- 02
Cluster.
Strip boilerplate and noise, split long entries into uniform windows, embed the text into vectors, compress and group them into distinct topics, and score how central each comment is to its group's theme.
- 03
Induce.
Rather than forcing the data into generic categories, the system reads the discovered groups and generates a custom, rigid data contract tailored to that population: the friction variables that actually appear, bounded to the five-state model.
- 04
Parse.
Read every comment against that contract and assign each friction variable a continuous score from 0.0 (none) to 1.0 (extreme). Anything off-topic is parked safely rather than forced into a category.
- 05
Graph.
Aggregate the individual scores into a master behavioral graph: set the baseline, compute how the friction variables correlate, and stamp both into the graph's metadata. Output: five nodes, seven transition paths.
- 06
Simulate.
Apply external and internal pressure to the compiled graph and recalculate where the population moves. This is the engine that powers the live model on the homepage.
- 07
Visualize.
Render the result as an interactive cockpit: push the pressures, watch the population shift in real time, read off the tipping point.
The pipeline has run on corpora north of 150,000 comments, filtering out roughly a fifth as noise before any modeling begins. The outputs live in Reports; this page is about how they're produced.
the physics
Tipping point analysis: why the readout is empirical, not assumed.
Empirical self-calibration
Most predictive models start from hand-entered assumptions about how people will react. Those assumptions carry someone's bias and go stale immediately. What counts as "agitated" in healthcare is not what counts as agitated in entertainment. dfmchn doesn't assume; it measures. Each population's baseline, the line between ordinary grumbling and genuine agitation, is derived statistically from the distribution of its own language, then stamped into the model. Every population is judged against itself, never against someone else's norm.
Cross-talk
Real pressures aren't independent. A small grievance lands far harder on a population already under strain. Financial stress makes a service slip feel like a betrayal. Rather than treating each friction in isolation, the engine derives the interactions between them directly from the data, so the model reflects how one pressure amplifies another.
The tipping function
Populations don't degrade linearly. They absorb pressure, absorb more, absorb more, and then move all at once. The engine models that with a bounded, non-linear response: below a population's threshold, added pressure barely registers; cross it, and behavior shifts sharply toward the exit. The response is capped at both ends, so the simulation neither runs away nor collapses. This is the cliff: the point where a small increase in pressure triggers a sudden, large migration.
the guardrails
The AI runs on rails. By design, it can't invent.
Generative models are useful for reading messy human text and unreliable if you let them roam. dfmchn lets the model read, and nothing else. It runs inside strict contracts:
- A closed state machine. The model can only classify transitions along the seven valid paths. It cannot fabricate new behavioral states.
- Bounded values. Every score is clamped between 0.0 and 1.0, with automatic correction if a limit is breached.
- A holding state. Off-topic or signal-free input (generic chatter, greetings) is routed to a designated holding category rather than forced into a label, so the model never returns a blank or a guess, and the noise itself becomes a data-quality measure.
- An identity fallback. Where a path has too few observations to be reliable, the engine defaults to a neutral identity matrix instead of inventing a relationship, so the simulation keeps running without manufacturing confidence it hasn't earned.
The net effect: the same input produces the same structured output, every time, inside known bounds. That's what makes a result you can put in front of a board, or stake a decision on.
the architecture
One engine, any population: churn prediction, customer attrition, price increase impact.
The simulation core is unit-blind. It never sees dollars, contract lengths, wait times, or product names; it operates entirely on unitless friction values between 0.0 and 1.0. Everything domain-specific lives in a separate translation layer that maps a population's real units into those friction values and back out into its own language for display.
Change the translation layer, and the same engine models a customer base, an electorate, a patient population, or a workforce, with no change to the underlying math. The horizontality isn't a marketing claim layered on top; it's a property of how the thing is built.
see what it produces, or bring us a population.