How We Simulate Users: The Engine Behind Marketrix
A technical breakdown of how we deploy synthetic personas that explore your product in real browsers and react like real users.
Most user research has the same bottleneck. You want to know how people will react to your product, so you recruit them, schedule them, run sessions, and wait. By the time the signal arrives, the feature has shipped or the moment has passed. You get a handful of data points, at high cost, and they come in late.
Marketrix takes a different approach. Instead of recruiting humans, we deploy synthetic personas that explore your product in real browsers and react to it the way real users would. This post walks through how the engine actually works, not the pitch.
Grounding the personas in your product
A persona that knows nothing about your product produces noise, not insight. So the first thing the platform does is build understanding.
You connect your application and provide whatever knowledge you have: HTML files, URLs, walkthrough videos, internal documentation. If you maintain analytics like PostHog, you can plug it in as a data source. On top of what you provide, our agents run deep research across the public internet to compile what is publicly known about your product. The result is a grounded model of what your product is and how it is meant to work, before any persona touches it.
This matters because the quality of a simulated study is bounded by how well the simulator understands the thing being studied. We treat that grounding step as foundational rather than optional.
What a persona actually is
A persona is not a system prompt that says “you are a busy procurement manager.” That would give you a caricature.
We model behavioral traits, triggers, interests, and a behavioral profile drawn from persona-modeling literature. Each persona carries the dimensions you would care about in a real study: what engages them, what frustrates them, how they approach an unfamiliar tool.
The important part is what happens at runtime. When a persona runs a task, the platform is not generating a single reaction to the overall journey. We spawn parallel reaction threads that respond to individual pieces of the experience: the specific screen, the placement of elements, the density of a form. If a persona is wired to dislike complexity and it lands on an interface crowded with buttons, that produces a genuine confusion signal at that exact step. The reaction is local and grounded in where it occurred, not a vague summary at the end.
So you get two layers running at once: the persona completing the task, and the persona reacting emotionally to each piece of the path it takes.
Skills, memory, and the novice-to-expert knob
This is the part of the engine we are most proud of technically.
As a persona explores your product, it accumulates skills. A skill is the practical know-how a first-time user would build up as they figure out how something works. The platform then gates those skills by the persona’s working memory.
If a persona has low working memory, we drop skills the way a dropout layer drops activations. The persona behaves like someone genuinely seeing your product for the first time, even on a later run. If a persona has high working memory, the skills it gathered before persist and get reused, so it behaves like an experienced operator.
This gives a continuous control knob between novice and expert. Run a study once and you are looking at fresh users. Rerun the same study and the personas ramp toward expert behavior, because they carry forward what they learned. In practice, after roughly three runs of the same study, the personas are substantially ramped up and their ratings begin to converge. You can watch that convergence as a trend, which is itself a useful signal about how much of a reaction is first-impression friction versus durable difficulty.
There is a second-order effect worth calling out. Because skills are tied to a persona’s memory model, a high-memory persona will get confused by a version change to your UI. It holds a prior notion of how the interface worked, and the change violates it. That is exactly the behavior you would want to surface before shipping a redesign to real users who have muscle memory.
Memory accumulates at the persona level, not just within a single study. A persona that runs multiple studies carries learning across all of them, and you can choose to use that full context or slide the experience back down to simulate a fresher state.
How execution actually happens
Each simulation runs in a short-lived virtual browser session. The persona drives the browser, fills forms, navigates flows, and the platform captures what it does and where it struggles in a live preview you can watch.
On the security side, the workspace is the boundary. Everything you bring in is scoped to your workspace. Credentials are encrypted and stored on our side, and when a persona needs to log in, values are passed as masked secrets. Credentials do not pass through the language model. Only the low-level browser commands that drive the automation receive real values. If running a cloud browser is a concern, the browser infrastructure can be swapped for one you control.
The output
The deliverable looks like a real user study, because that is the point.
For each persona you get an overall impression, then per-question breakdowns. Each question carries an essay-style answer plus emotional ratings: how satisfied they were, whether they were confused, whether they felt they could trust the product. Each answer is traceable to the specific segments of the flow the persona used to form it, so an insight is not a floating claim. You can see what produced it.
You can scale the subject pool from a handful to whatever you need for statistical significance, and export everything to PDF or a spreadsheet to run your own analysis.
Why we built it this way
Our thesis is that the structure of a real user study is reproducible if you model the right things: grounded product understanding, persona-level behavior, local reactions to the actual interface, and a memory model that distinguishes a first-time user from a veteran. Get those right and you can run the study before you have built the thing, or before a single real user has seen the change.
That is what we mean by simulate first. A million users before your first user.
Try it
Marketrix is the simulation layer for digital products. If your team has a blind spot in the parts of the product real users never call you about, that is exactly where simulated user studies do their best work.
Spin up a workspace and run your first study, or reach out and we will help you scope one around a specific flow you want insight on.