The six layers of AI experience.
What if the AI experience you see is only a small part of what actually shapes it?
What are the six layers of AI experience?
The six layers of AI experience are user interfaces, context, harness, model, governance and emergence. Defined by design leader Emily Campbell, the framework explains how an AI product's experience is shaped not only by its interface but by the interdependent systems beneath it — and why designers now need fluency across all six.
- User interfaces — where people direct and oversee AI behaviour.
- Context — what the system knows and infers about the user.
- Harness — connectors, tools, skills and agents: what the model can access, use and do.
- Model — the training, capabilities and behaviour that shape the model itself.
- Governance — rules, standards and preferences that set the AI's parameters.
- Emergence — variance and unknown behaviour, revealed through real-world use.
Key takeaways
- AI design has moved from deterministic (Garrett, 2000) through anticipatory (Mill) to probabilistic design (Campbell).
- The layers are interdependent: a small change in one can have an outsized effect on the whole experience.
- As context and trust grow, interfaces shift from direction to oversight — Campbell calls this progressive autonomy.
- Too much context causes context rot; too little makes the AI inconsistent.
- Emergence can't be configured, only designed around through observability, interpretability and provenance.
- Full-stack AI designers don't need to own every layer, but they need fluency across all of them.
Chapter 01 · Introduction
The interface is only the beginning.
It has been only three and a half years since ChatGPT was released to the public. We are still early in understanding how this generative material works, how it fits into tasks and journeys, and how it changes what we build and for whom.
What is clear, Campbell argues, is that we are entering a renaissance of new design roles and new opportunities for design influence. The arrival of generative AI has upended the interaction model that anchored the previous era of design. Great AI products are multi-dimensional. Small changes to one dimension can have an outsized impact on the whole.
Diagram: a chat-style interface card rests on a stack of six layers — user interfaces, context, harness, model, governance and emergence. The upper four layers describe how the experience is composed; governance and emergence describe the conditions under which it operates. Lines connect every layer back to the interface, showing that each response carries traces of all six.
The surface is where most of the conversation happens.
AI design discourse is still heavily weighted toward the interface: chat, prompts, and familiar patterns adapted for generative interactions. That is not surprising — the interface is where most people first meet AI, and generative systems usually need an input before anything can happen.
But a screen designed in isolation explains very little about why the AI behaves the way it does.
Beneath the surface sit context, harness and model.
What the system knows about the user, what it is allowed to access and do, and how the underlying model was trained all shape every response before it reaches the screen.
Every interaction may include traces of decisions, biases, references and dependencies from the model, its training data and its available tools — plus any outside context brought into the conversation.
Below that: governance and emergence.
Rules, standards and preferences — often set outside the product team — define what the system may and may not do. And because the model itself is probabilistic, some behaviour only reveals itself through real-world use.
The experience is produced by every layer at once.
Campbell's framework treats these as highly interdependent layers that collectively shape how a product behaves. We cannot control every outcome through the interface, but we can design the conditions that shape a model's generation.
Try the button beside the diagram: change one thing deep in the stack, and watch the response at the surface change too.
"Spare me the 'design is dead' takes," Campbell writes. "Design is more important than ever." The form of the work is evolving, as it has before, to meet a changing medium. To see how, it helps to look back at two earlier models of what design is responsible for.
Chapter 02 · Foundations
How design thinking evolved.
The idea of design as a multi-layered domain is not new. What is changing is how complex the system is as a whole — and how deep into that system design can now reach.
Timeline diagram with three paradigms. Deterministic design (Garrett, 2000) shows five planes from strategy to surface. Anticipatory design (Mill, 2020) adds the problem space and the real world beneath the product. Probabilistic design (Campbell) adds the layers beneath the interface: context, harness, model, governance and emergence.
Garrett: five planes, each dependent on the others.
On the early web, work was segmented by role. Visual designers owned the interface, information architects owned navigation and structure, business stakeholders owned requirements. Each discipline tended to optimise its own area rather than the product as a whole.
In 2000 Jesse James Garrett published The Elements of User Experience, showing that websites were composed of planes — from abstract strategy up to the concrete surface — each dependent on the one below. Navigation reflected product strategy; usability problems in the interface could reveal weaknesses in the architecture underneath.
Specify every state, coordinate every plane.
"The user experience development process is all about ensuring that no aspect of the user's experience with your site happens without your conscious, explicit intent."
Myopic optimisation harmed the experience, so designers had to understand what the whole system produced. The result was a highly deterministic model: understand the user's goals, map their journeys, and coordinate decisions across all five planes to shape the final product intentionally.
Mill: the problem space and the real world.
Twenty years later, Jamie Mill revisited the framework as The Elements of Product Design. As products became algorithmic and adaptive to user data and behaviour, designing for every possible use case became harder.
Beyond Garrett's solution space, Mill added the problem space — where discovery reveals user needs, the domain and observed behaviour — and the real world: complex, contradictory, evolving, with constraints, incentives and existing mental models that shape how a product is understood.
Many of those forces are decided outside the design team. Design became outcome-oriented: anticipate the less predictable conditions around the product and facilitate a process that leads to better outcomes.
Campbell: one layer deeper again.
With generative AI, it is no longer only the algorithm that introduces variability. The underlying model is itself probabilistic, creating behaviours and emergent patterns that cannot always be reduced to explicit rules, states or predefined paths.
So the work looks less like specifying every expected state and more like system design: finding the leverage points that exist in the layers below the surface. Garrett asked designers to look beyond the layer they controlled. Mill asked them to look beyond the product. AI asks them to go into the model, the harness, the context, the policies and the emergent behaviours that produce the experience before it ever reaches the interface.
Full-stack — but not in the engineering sense.
Campbell calls for full-stack designers. Not machine-learning engineers, policy experts or model researchers, but people who are multilingual: able to discuss fluently how each layer beneath the interface affects the user experience, and how to intervene when necessary. She links this to systems thinking: when direct control is limited, you study the system to find where effort has the greatest leverage.
Chapter 03 · The framework
Meet the six layers.
AI experience is composed of highly interdependent layers that collectively shape how a product behaves. Early on, interactions depend heavily on direct instruction. Over time the system takes over more of the work — managing the user's needs through context, running within its harness, shaped by its model and governance, and checked by user oversight.
- 1 · User interfaces
- Where users direct and oversee AI behaviour, evolving from an input surface to a command centre as the model works more independently, guided by its harness and the user's context.
- 2 · Context
- User inputs sent directly via prompts, uploads, configurations and connections at first, expanding to include knowledge inferred from behavioural patterns, integrated systems, historical interactions and the content it has permission to access.
- 3 · Harness
- The operational layer that determines what the model can access, use and do, allowing the AI to complete tasks independently while remaining governed by constraints and user preferences.
- 4 · Model
- The training, capabilities and behaviour that determine which tasks and modes the model excels at and shape how it performs in practice.
- 5 · Governance
- Rules, standards and preferences that determine what data the AI can access, what it's allowed to do, what it must refuse or explain, and where humans remain in the loop.
- 6 · Emergence
- The variance and unknown behaviour that appear when probabilistic systems operate in the real world. Designers cannot eliminate emergence, but they can design the conditions that make unwanted behaviour easier to observe and correct.
The six layers of AI experience at a glance
Layers 1–4 describe how the experience is composed; layers 5–6 describe the conditions it operates in.
| # | Layer | Core responsibility | Components |
|---|---|---|---|
| 1 | User interfaces | Where people direct and oversee AI behaviour | Direction, oversight |
| 2 | Context | What the system knows and infers about the user | Explicit, inferred |
| 3 | Harness | Structure that determines what the model can access, use and do | Connectors, tools, skills, agents |
| 4 | Model | Training, capabilities and behaviour that shape the model itself | Training, capabilities, behaviour |
| 5 | Governance | Rules, standards or preferences that set the AI's parameters | Rules, standards, preferences |
| 6 | Emergence | Variance and unknown behaviour, revealed through use | Observed, not configured |
Chapter 04 · Layer 1
User interfaces: from direction to oversight.
Where people direct and oversee AI behaviour. Interfaces are not going to disappear, but their role changes the deeper a user goes into a session — increasingly supporting the system rather than driving it.
The weekly exec update is drafted in the background, guarded by evals.
- Exec update drafted · 142 wordsNeeds review
- Meeting with John held for Thursday 3pmDone
- Support escalation · handled cautiouslyNeeds review
All three shape the next background run.
Early on, AI needs direction.
At the start of a journey, people guide the AI's goals, constraints, context, inputs and instructions. We have taken to calling these prompts — and writing long, specific, context-rich prompts on every turn is inefficient and, frankly, annoying.
A product that relies strictly on prompts has a ceiling for engagement.
Prompting is only one surface.
Inline actions, ambient nudges, user-defined workflows, connected services and structured inputs offer a palette of alternatives for instructing the model — each carrying intent without a paragraph of typing.
Onboarding becomes the system learning the user.
Traditional products onboard people into the product, disclosing advanced features progressively. In AI products, onboarding looks less like people learning the system and more like the system learning to interpret the person.
The faster a model grasps the user's intent, the faster it becomes an augmenting utility.
Less complication needs to appear in the interface.
The better the system understands the person, the less the interface has to ask. Campbell calls this progressive autonomy. The same task for the same user might need direct instruction early on, but could eventually be served by an autonomous background process guarded by evals — once the system has earned the user's trust.
The interface leans toward oversight.
When the sub-surface system works well, the model acts with more autonomy, and the interface becomes the place where people monitor activity, review results, manage autonomous workflows, orchestrate agents and intervene when needed — without constant intervention.
Try it: approve the drafts or pause the agent.
Match the surface to the relationship.
Chat can still be effective, but it is not a stable state. Interfaces may begin to resemble instrument panels, allowing direct inputs without requiring them. The right surface depends on how familiar the user is with the domain, how much the AI knows about them, how sensitive the situation is and how confident the system is in its response.
Behind the scenes, designers also need surfaces where people can view and adjust memory, skills and instructions — and evaluation tools that track accuracy and flag issues.
Chapter 05 · Layer 2
Context: the engine beneath the interface.
Below any AI interface sits the context that gives the model clues about the user's intent, needs, constraints and ecosystem. A well-constructed context keeps an AI experience from starting cold every time someone asks for help.
Explicit context
In early interactions the user helps the model understand them through explicit inputs: descriptions of goals and concerns, preferences, instructions, uploads, configurations, and imported third-party content and data.
Inferred context
Almost immediately the system begins to generate inferred context from behavioural patterns, integrated systems, historical interactions and the content it has permission to access. Together, explicit and inferred context form a working context layer the system uses to interpret future requests.
Like exploring a map in a video game
At first most of the terrain is hidden. As you move through it, the map reveals its topography, buildings, hazards and boundaries — becoming more useful as you go. Context works the same way: the system learns how the user works, what they care about and how they prefer to be helped.
Context engineering
Designers shape this layer deliberately through context engineering — deciding what should be collected, retained, passed between interactions, and discarded, and how context should evolve over time.
Reveal the map.
Illustrative simulation · values are not measuredAdd what the user tells the system, let it observe, then see what happens when context is never maintained. The examples come from Campbell's article; the scoring is a teaching device.
User tells the system
System observes
Over time
Working context
Context rot
A system needs help knowing what to keep and what to discard. Too much context — long context windows and bloated memory files — burns through token budgets and can degrade results, a failure commonly called context rot. Too little or unmaintained context leaves the system inconsistent, unpredictable or dependent on constant user intervention.
Both get worse when the system remembers personal details it should not have, forgets things it should know, or carries forward the wrong context from another user or session.
Design for the agent, too
As agents take a more active role in driving workflows and handling data on a person's behalf, designers need to consider the agent's experience as well: how it receives context, how it manages goals, when it collaborates with the user, and how visible its actions need to be for review.
That is why the UI and context layers must be designed in tight harmony — for people and for AI agents, and for where their workflows intersect across journeys.
Chapter 06 · Layer 3
Harness: what the model can access, use and do.
As experiences become more headless, more of the product's work moves out of the visible interface into context-aware, autonomous background processes. AI systems need an operational layer around the model — a harness — that lets it complete tasks independently while staying governed by permissions and user preferences.
It can look like the domain of developer experience or application architecture, but harnesses are increasingly part of the user experience. They shape what the system can know, what it can do, how consistently it behaves and how much control users have over autonomous work.
In practice it is the difference between an AI you can chat with and one that operates as a true collaborator — finding and managing data, drafting responses, routing information and coordinating actions toward a goal.
There is no single form a harness must take. It can be simple, orchestrating one agent's workflows, or manage a more complex orchestration in which a central agent deploys and oversees several sub-agents in pursuit of one outcome.
Either way, four components work together. Together they form the operational surface of AI systems — the boundary between human intent and machine execution.
- Connectors
- Determine access: what data the model may view and manipulate, in what context and under what conditions. Third-party connections change the model's context, so people need to see what is connected and how it shapes outputs.
- Tools
- Determine action: reading and writing emails, updating records, triggering workflows. Too loose and actions have unintended consequences; too restricted and advanced work needs constant intervention.
- Skills
- Reusable working knowledge: methods and rules for processing information, required formats and criteria, and task instructions. People need visibility and control over which skills are active and what assumptions they contain.
- Agents
- Autonomous systems that combine skills, tools and data access toward specific goals, working in loops of delegated responsibility. Good agent experiences let people observe and interrupt without micromanaging.
Run the harness.
Illustrative scenario · not a fixed execution orderHypothetical task: "Follow up with the client after Thursday's meeting and log it in the CRM." Change what the harness allows and watch how the work moves — and where it stops.
Flow diagram: user intent passes through connectors, then context and data access, then tools, skills and agents, ending in a task outcome. Nodes that are disabled by the current settings are shown dashed.
What the harness allows
Tool permissions
What happens
This increase in autonomy is what drives the changes at the context and UI layers: the user experience shifts from directing a single model to supervising agentic systems. A good agent experience makes autonomous work feel orchestrated — people can observe and interrupt without micromanaging every step.
Chapter 07 · Layer 4
Model: models are not interchangeable.
To a lay user, flagship systems like GPT, Claude, Gemini and Grok can look interchangeable. But the landscape is far broader — small and large, general-purpose and vertical, open and proprietary — and each model carries distinct characteristics into the end product.
Tone and personality, tolerance for risk or ambiguity, general reliability: these differences are not arbitrary or merely technical. They persist across labs and providers, and between different models from the same lab.
Models are first a reflection of their training — the data, tuning, learned weights and reinforcement methods used to shape their character. That determines what a model knows by default, how it responds in different contexts, what it avoids and which assumptions it carries into each interaction.
A model trained to focus on reasoning is a poor fit for fast-moving, low-risk environments where latency is costly; a faster model may feel more fluid, with less nuance or reliability.
Training shapes capabilities: what a model is specifically designed to do. One may excel at reasoning, another at speed; one may be better at writing, coding, tool use or multimodal understanding, and so suit some tools and domains better than others.
Designers influence task design: what to delegate to the model, what stays with the user, and how the interface can narrow a task so the model performs well. Expecting users to understand the model landscape is unreasonable; preset modes can carry that choice for them.
Behaviour can be designed by defining trade-offs up front. A reasoning model can accept different effort levels, trading depth and accuracy against latency and cost. A creative model can accept fewer turns per generation — a draft mode that lets people iterate while managing token spend.
Latency, verbosity, confidence, refusal patterns, creativity, consistency and reasoning depth can all be tuned, and together give a product its distinct feel.
Tune the trade-offs.
Educational simulation · not benchmark dataStart from a model trained for…
For this task
Fit for this task
Good fit.
Sample response style
A powerful model can still be a poor fit if its capabilities do not match the need. Because models are the primary material of AI products, designers need enough fluency to reason about their trade-offs. They do not need to train models themselves — but the better they understand how models behave, the more effectively they can play to their strengths and constrain their risks.
Chapter 08 · Layer 5
Governance: the parameters around the product.
The first four layers describe how an AI experience is composed. Governance and emergence shift the frame from composition to operation. They are often not owned by the product team, but they directly shape the conditions in which AI products are deployed and used.
Policies, regulations, standards and preferences all govern the experience, directly or indirectly — and every layer feels it: data-retention preferences affect context storage, a company's philosophy shows up in model behaviour, and standards determine what counts as acceptable performance.
So governance cannot be treated as separate from the product, even when its decisions live in legal, compliance, security or executive teams. Every combination of these decisions can produce a meaningfully different experience for two people using the same model.
Campbell's example: a product built on a model from Anthropic versus one from OpenAI. Each company makes different choices about model design, training and safety, and those choices surface as interaction patterns — what the system will answer, how cautious it feels, when it refuses, how it explains boundaries and how much control product teams have.
A model that refuses an action is itself an interaction, compared with a model that is eager to act.
Govern one workflow three ways.
Hypothetical workflowScenario: a support assistant handles a customer's refund request. The model is the same throughout — only governance changes.
Rules
Mandatory · the hardest constraintsLaws, policies and explicit restrictions: what the product must do, must not do, when to disclose or ask permission, and where it has to stop.
Standards
Evaluation criteria · optimal behaviourAccuracy, fairness, accessibility, safety and performance translated into criteria the system is designed and evaluated against.
Preferences
Configurable · unenforceable, but influentialVoice and tone, saved memories, autonomy settings, product personality — gates and incentives that shift behaviour over time.
Tone
Autonomy
What the product does
The reply the customer sees
Preferences move models, too
Preferences are unenforceable, yet they generate gates and incentives that shift the behaviour of models and training systems over time. When Sam Altman publicly said GPT-4o had become "too sycophant-y and annoying" and that the company was prioritising adjustments, he was responding to a mismatch between the model's tuned personality and what many users wanted.
Where designers come in
Designers can influence governance directly through service and policy design or advocacy, or indirectly by shaping the preferences of others — brand and communication design are especially effective here. At a minimum, designers need to understand the governance framework they operate in, which may call for different first-time UX, preferences, expectations and interactions.
Chapter 09 · Layer 6
Emergence: designed around, not configured.
AI experiences are shaped by emergence — the unexpected behaviours that arise when probabilistic systems operate in real-world contexts. There is more we don't know about these models, and more we don't know that we don't know, than we can confidently explain.
We often don't know what a model is capable of until it is put into play — by which time the unexpected behaviour may already have reached customers.
Models behave differently across sessions and contexts, users, tools, versions, permissions and interaction histories. That variance makes AI products hard to debug: a strange generation could come from the model's training, its harness, outside sources or context, or simply the path the interaction took.
Variance is also a strength when used intentionally. In creative tools, variation lets the system generate alternative paths for exploration, or break out of an anchor that is running stale.
Randomness is a necessary part of these experiences — a feature, not a bug. Uncertainty is part of what gives generative systems their value.
Same request, run again
Hypothetical outputsRequest: "Summarise this week's customer feedback for the product team."
What differs between runs
Run history
Output
Something unexpected. How would a team investigate it?
See what the system is doing and how it is behaving.
- Step 1 · requestWeekly summary requested by the product team.
- Step 2 · connectorFeedback inbox read, plus one long imported thread.
- Step 3 · skill"Weekly digest" applied: lead with the top theme.
- Step 4 · generationDraft produced.
- Step 5 · evalRepetition check failed — run flagged for review.
Understand why the system appears to follow a particular path.
These weights are illustrative. Interpretability offers a partial view of how a system appears to reason — not a complete account of a model's internals, which we are unlikely to fully dissect any time soon.
Work backward from the generation to see how it was formed.
Likely fix: adjust the harness — weight sources evenly and soften the skill rule — then re-run the eval.
When emergence shows up in real products.
The examples Campbell cites, as she describes them.
The "goblins" incident
OpenAI identified that GPT-5.5 had an "odd affinity for goblin metaphors" — apparently a relic of training for the optional "geeky" persona. A small personality-training incentive grew into models mentioning goblins in completely irrelevant moments.
Cited by Campbell, footnote 2
Unintelligible messages
The AI app Poke sent random, unintelligible messages to a user in the middle of a conversation.
Cited by Campbell, footnote 3
Three pages of "there"
Google AI results once returned three pages of the word "there" — and only that word — for a search about showtimes at the New York City planetarium.
Cited by Campbell, footnote 3
Strong on hard, weak on easy
Models that do well on complex tasks but more poorly on simpler ones, or that seem to glitch out from random tokens.
Described by Campbell
Design the conditions.
The goblins episode is funny, but it shows how small changes at the model level can cascade into visible product behaviour in ways teams can't anticipate. The goal of design is not to eliminate variance or unknown behaviour, but to design conditions that minimise or mitigate its effects — and make it easier to observe, diagnose and correct where possible.
That is what makes emergence different from the other layers. It is not configured directly. It is designed around, monitored for and responded to.
Observability
Helps teams see what the system is doing and how it is behaving — through evals, traces and other tools.
Interpretability
Helps people understand why the system appears to follow a particular path.
Provenance
Helps teams work backward from a generation to identify how it was formed.
Chapter 10 · What this means for design
The future of full-stack AI design.
AI product experiences are not created by the interface alone. They emerge from the interplay of user interfaces, context, harness, model, governance and emergence.
Direct control or system leverage?
Campbell's model runs two axes alongside the stack. Near the surface, designers have the most direct control. The deeper they work, the more leverage their input has on the final product. Move through the layers to see the trade.
Relative positions from Campbell's diagram, not measurements.
The expectation should not be that every designer works across every layer. Full-stack AI designers need general fluency across all the inputs into the experience, so they can influence, mitigate or absorb the impact upstream work has on the end experience.
In his 2017 Design in Tech Report, John Maeda noticed designers becoming more technical while also capturing the lasting value of traditional design: classical design, design thinking and computational design are complementary, not competitive.
Technical designers are more likely to focus on the model, harness and context layers — a role larger than "design engineer". Others may work further down the stack, as design-specific titles appear in policy-making and emergent research; such roles exist today under titles like "business designer", but have not reached critical mass. Classical design will remain, while its workflows, tools and outputs evolve.
Three ways designers create leverage.
From Campbell's companion diagram, The changing role of design.
Influencing scale
Designers as amplifiers.
Where trust is a constraint, brand becomes a moat. Because AI improves the more people use it, strong brand affinity can shorten the context-building cycle by easing the intimidation of technical adoption, role transformation or workflow change.
Influencing speed
Designers as builders.
The faster teams ship, the faster they learn. Designers who build shorten the cycle between ideation and delivery, and can explore several directions in parallel — lowering risk and enabling bigger bets.
Influencing systems
Designers as architects.
The more someone uses AI, the more of the experience is managed below the interface. Service designers might shape corporate policy, model designers and researchers might define the success criteria behind rubrics and evals, and product designers might find patterns for orchestrating agents at scale without losing control.
The point of all six layers
Design the conditions, not only the screen.
The interface is where AI is experienced. The layers beneath it are where that experience is decided. Designers who understand those layers — and where to apply their effort — are the ones who will shape what AI becomes.
Quick answers
Frequently asked questions.
What are the six layers of AI experience?
The six layers of AI experience are user interfaces, context, harness, model, governance and emergence. Defined by Emily Campbell, they describe how an AI product's experience is shaped both on screen and beneath it: where people direct and oversee the AI, what it knows about them, what it can access and do, how the model was trained, the rules it operates under, and the behaviour that only appears through real-world use.
Who created the Layers of AI Experience framework?
Emily Campbell created the Layers of AI Experience framework (2026). It builds on Jesse James Garrett's The Elements of User Experience (2000) and Jamie Mill's The Elements of Product Design, extending design thinking from deterministic and anticipatory design to probabilistic design for generative AI.
What is the difference between deterministic, anticipatory and probabilistic design?
Deterministic design (Garrett) specifies every state across five dependent planes, from strategy to surface. Anticipatory design (Mill) widens the lens to the problem space and the real world, focusing on outcomes rather than fixed states. Probabilistic design (Campbell) accepts that generative models create variable behaviour, so designers shape the conditions beneath the interface rather than specifying every outcome. See the timeline.
What is context rot in AI products?
Context rot is the degradation of an AI system's results caused by too much context, such as long context windows and bloated memory files that burn through token budgets. Too little or unmaintained context causes the opposite problem: inconsistent, unpredictable behaviour that depends on constant user intervention. Context engineering decides what to collect, keep, pass on and discard. Try the context map.
What is an AI harness?
An AI harness is the operational layer around a model that determines what it can access, use and do. It has four components: connectors (what data and systems it can reach), tools (what actions it can take), skills (reusable working knowledge such as methods, formats and rules) and agents (autonomous systems that combine all three toward a goal). Run the harness simulation.
What is progressive autonomy in AI UX?
Progressive autonomy is the idea that the better an AI system understands a person, the less complication needs to appear in the interface. Early on, users direct the AI with goals, constraints and instructions; as context and trust grow, the system acts more independently and the interface shifts toward oversight: monitoring, reviewing and intervening when needed. See the interface evolve.
Why are AI models not interchangeable?
Each model carries distinct characteristics from its training, capabilities and behaviour, including tone, personality, tolerance for risk and ambiguity, and reliability. A reasoning-focused model can be a poor fit for fast, low-risk tasks where latency is costly, while a faster model may lack nuance. Designers need enough fluency to match models to tasks, without training models themselves. Tune the trade-offs.
How does governance affect AI product design?
Governance — rules, standards and preferences — sets the parameters for every other layer. Rules are mandatory constraints such as laws and disclosure requirements; standards are evaluation criteria such as accuracy, fairness and accessibility; preferences are unenforceable but influential settings such as tone, memory and autonomy. Different governance choices can create meaningfully different experiences on the same model. Compare two governance profiles.
Can designers control emergent AI behaviour?
Not directly. Emergence is variance and unknown behaviour that appears when probabilistic systems meet real-world use. Designers cannot configure it, but they can design the conditions around it and make unwanted behaviour easier to observe, diagnose and correct through observability, interpretability and provenance. Investigate an unexpected output.
What is a full-stack AI designer?
A full-stack AI designer has general fluency across every layer that shapes an AI experience — interface, context, harness, model, governance and emergence — and can discuss how each affects users and where to intervene. It does not mean becoming a machine-learning engineer, policy expert or model researcher, or owning every layer. Read the conclusion.