The interface reshapes itself to who the user is, what they are doing, and what they need next. One product. Infinite shapes. A new contract between software and the people who use it.
The system observes, infers, reshapes, and refines — in real time, every session, for every user. Every interaction is signal. Every signal makes the next interaction better.
Behavioural signals, telemetry, role hints, current task context. No spying; just thoughtful instrumentation.
A small frontier-model loop turns signals into a live representation of who you are and what you need next.
Layout, content depth, copy, primary actions, even pricing — rendered for this person, this moment.
Every interaction trains the next render. The product gets sharper as it learns the user, the cohort, the world.
We are practising what we preach. The section below changes its content, depth, and examples based on the persona you select above. Try each one.
Adaptive AI is not a single model call. It is a small, tight pipeline of cheap classifiers, a long-context frontier model, a deterministic renderer, and a feedback bus. The render layer is the surprise — most teams over-invest in model choice and under-invest in the adaptation surface.
A representative architecture:
// Adaptive surface contract
type AdaptiveRender = {
persona: 'coder'|'pm'|'founder'|'student'|'researcher';
intent: 'learn'|'evaluate'|'build'|'buy';
density: 'sparse'|'normal'|'dense';
sections: Section[];
};
type Section = {
kind: 'hero'|'code'|'diagram'|'usecases'|'pricing';
depth: 1|2|3|4|5; // 1=overview, 5=research
props: Record<string, unknown>;
};
// The model returns a Section[], not markup.
// Your renderer maps kinds → components.
// Determinism stays in your code.The moat is in your event taxonomy, your component library, and your reward loop. Models swap; surfaces compound.
Target <800ms for visible adaptation. Cache the inference, stream the render, and reserve frontier calls for moments that matter.
Adaptive UIs without offline evals drift quietly. Snapshot persona × intent × depth and replay before every prompt change.
Most PMs treat personalisation as recommendations on a static shell. Adaptive AI is the next layer: the shell itself becomes a function of the user. You will not get there in one sprint, but the staging is clearer than it looks.
Build a live user-context object: role, intent, journey stage, task graph. Make it observable. Show it in the UI — even debug-only. If you cannot describe your user in one JSON, you cannot adapt to them.
Every screen gets a "depth dial." Same content, three depths: overview, working, expert. Start with two surfaces (onboarding, primary dashboard) before going wider.
Rules-engine personalisation maxes out at 5–7 dimensions. An LLM lets you adapt on hundreds of soft signals at once. Replace your rules engine with a contract: signals in, render-schema out.
Every adapted render emits an outcome. Wire it back. The product gets sharper with usage instead of decaying under feature debt.
First-meaningful-action rate, because the right action is now the obvious one.
No more 9-step tours. The product opens at the step the user actually needs.
Power features surface to power users; novices never see what would scare them.
Most tickets are UI mismatch tickets. Adaptive UI removes the mismatch.
Every category leader of the last cycle won on a single insight: remove a step the user used to take. Search removed the directory. Uber removed the dispatcher. Stripe removed the integration. Adaptive AI removes the step that has been hiding in plain sight for forty years — the user learning the product.
That step is invisible because we built our entire industry around it — tutorials, tours, onboarding, docs, support, training, certification. Strip them away, and the product itself has to do the work. Whoever ships that first in your category wins the next five years.
Activation goes up. Refunds go down. Each acquired user is more valuable on day 7.
When the product proves its worth in the first session, you can charge for outcomes, not seats.
Your adaptation telemetry becomes the asset competitors cannot replicate. They have prompts; you have priors.
Think of every app you have ever opened. The buttons were in the same place for everyone — a 70-year-old grandmother, a teenager, a surgeon, a software engineer. Everyone got the same screen, and everyone had to learn it. Adaptive AI flips that: the app looks at who you are and what you are trying to do, and changes itself to fit you.
It is the difference between a giant Swiss-Army knife with 50 tools sticking out, and a knife that quietly shows you only the blade you need right now.
Opens to "today's surgeries" for a surgeon, "patient queue" for a GP, "lab results" for a pathologist — same app, three different first screens.
Shows extra worked examples to a learner who got the last quiz wrong, and skips ahead to practice questions for the one who got it right.
For a first-time visitor, it explains sizes and returns. For a returning customer, it shows the colour they almost bought last week.
For a salaried user, it leads with savings. For a small-business owner, it leads with invoicing. For a senior citizen, it makes text larger and removes clutter.
Difficulty rises and falls based on how you are doing — not based on a setting you picked once and forgot.
Asks two questions, then hides every form and scheme you do not qualify for. Suddenly "the system" is no longer something to fight.
The simplest experiment is to build the same screen twice for two different users, then ask: "what is the smallest signal that lets a model decide which version to show?" That question is the entire field in one sentence.
We can define an adaptive interface as a function
f: (U, T, C, H) → R, where
U is a representation of the user (latent, partially
observed), T is the task context, C
is the broader environmental context (device, locale, time,
cohort drift), H is the interaction history, and
R is a typed rendering schema. Three properties matter:
1. Identifiability. The user representation U must be learnable from observable signals without collapsing distinct users into a single mode. Most static personalisation systems fail here because they operate on hand-coded segments. A latent embedding learned from task-conditioned behaviour (analogous to a tower in a two-tower recommender, but conditioned on intent rather than item) tends to preserve identifiability under cohort drift.
2. Stability under noise. The mapping f
must not change drastically for small perturbations of U or T —
otherwise the user perceives the interface as flickering and untrustworthy.
We enforce this with a temporal smoothness regulariser on R: render
schemas are penalised for high edit distance from the previous render
unless an interaction event of sufficient weight has occurred. This is
conceptually similar to trust-region updates in policy optimisation.
3. Counterfactual reasoning. Because we only ever observe outcomes for the render we shipped, every deployed adaptive system has a logged-policy / target-policy gap. We use inverse propensity scoring and small online exploration arms (Thompson-like sampling over render variants) to keep the gradient honest, but the bias-variance trade-off here is genuinely difficult and remains an open area.
A model rewarded for engagement will, given enough degrees of freedom, learn to be sticky in ways the user did not endorse. Reward shaping for adaptive UI is a special case of the alignment problem with unusually fast feedback loops — which makes it both tractable and dangerous.
What is the right basis for the user-state vector? Role, mood, skill, intent, fatigue, recent context — these are not orthogonal. We are interested in self-supervised pre-training of user-state representations from task trajectories across products.
Memory makes adaptation deeper but raises the bar on consent, retention, and right-to-forget. The technical and ethical frontiers here advance at different speeds; we think the right answer is local-first memory with explicit user-visible state.
There is no "correct" interface for a user; only better and worse. Standard A/B tests are not enough — they reward short-horizon metrics. We are exploring multi-fidelity evaluation that combines offline replay, expert review, and small-cell long-horizon trials.
The illustration below shows the same dashboard rendered for three roles. The components are identical. The composition is not.
The introduction above is free and unconstrained. Our advanced material — reference architectures, evaluation harnesses, component libraries, and the playbooks we have built for paying clients — sits behind a short conversation.
A short call, a small engagement fee, and we share what is otherwise reserved for clients. We work with a handful of teams at a time, by design.
Start a conversationTell us what you are building. We will tell you the shortest path to an adaptive surface, whether you build it with us or alone.