> ## Documentation Index
> Fetch the complete documentation index at: https://agent.minimax.io/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# HAI: Principles of Human-Agent Interaction

> Tracing the full arc of collaborating with agents—how intent forms, how intent is delegated, how to treat high-speed black-box execution, and how software interfaces and execution substrates should be redesigned.

Most software that people use every day still rests on one contract: the computer is a deterministic tool, the person issues an explicit command, and the interface answers at once. Once the counterpart becomes an agent that plans on its own, calls tools, and keeps changing external state, that contract begins to break down.

Grounded in our product practice, this essay starts with three questions:

1. Why does most AI usage outside software engineering still struggle to penetrate real-world workflows?
2. Why are strong engineers growing more exhausted in the age of AI, while some junior practitioners regress into "wishing machines"?
3. Today's agents tend to expose their execution traces—why doesn't that make outcomes more controllable?

We do not think these questions are peculiar to us; they are practical problems that any team building agent products will meet. The first three sections take them one at a time and give our answer to each. The fourth states our position: what we think software should do in response. Following the course of a collaboration—how a person forms intent, how they hand it over, how they relate to a fast process they cannot follow, and how the interface and the substrate under it should be rebuilt—we need a coherent set of principles for Human-Agent Interaction (HAI).

| | Question | Our answer | Where we could be wrong |
| - | - | - | - |
| 1 | Why does most use of AI outside coding stay shallow? | Intent forms in an environment, and a blank box evokes little of it. | Models with memory and initiative may supply the missing cues without a new surface. |
| 2 | Why are the best engineers more tired, while some become "wishing machines"? | Delegating intent is not delegating a task. Between *What* and *How* lies *Why*; it lives in output contracts, and faster agents widen the gap. | Agents may learn to elicit and maintain contracts themselves. |
| 3 | Why has showing the process not given control? | Machine speed makes raw transparency unreadable. Fold what is reversible; surface the model's assumptions at key nodes fixed in advance. | For open-ended tasks there may be no nodes a designer can fix in advance. |
| **Position** | | For people: intent guidance and intent editing, a middle state with a few handles. For agents: intent execution, a deterministic substrate with atomic permissions. | Some crafts think through the controls we fold; atomic access widens what a hijacked agent can do. |

> [!NOTE]
>
> Product figures in this essay are given only as coarse tiers and directions; the charts built from them are schematic and carry no scale.

***

## 1. Formation of Intent

**The question: why does most AI usage outside coding still struggle to reach real workflows?**

**Our answer: intent forms in an environment.** People do not arrive with finished intent. They form it in response to what is in front of them, and a blank chat box puts almost nothing in front of them. This, more than any lack of prompting skill, is what keeps agents out of everyday work.

### 1.1 Surplus Model Capability Does Not Automatically Translate into Deep Workflow Adoption

Today's mainstream coding agents already possess capabilities far exceeding the complexity of routine white-collar tasks: they can read and write hundreds of local files, write scripts to clean data, reconcile ledgers and contracts, chain external APIs, and even build a custom utility on the spot.

Yet watching how most people actually use coding agents or general chatbots day to day reveals a stark gap: high-frequency interactions remain confined to a handful of stereotyped tasks—generating a slide deck, drafting a notice, or asking a legal or financial question. Most of the time, AI still functions as little more than an "advanced search engine," rarely embedding itself into everyday workflows. This is not peculiar to us: in the largest public study of a consumer chatbot, practical guidance, seeking information and writing together made up nearly 80% of conversations (Chatterji et al., 2025).

Our own usage has the same shape. Office and business work is about half of the usage we can classify. Within it, the two largest categories are still information retrieval and standalone knowledge artifacts, and together they form a clear majority. Tasks that genuinely reach into operational workflows—data analysis, study and research, functional business processes, and collaboration—are together a minority. Measured by unique users rather than session volume, the share of people who deeply integrate AI into daily office work is smaller still.

![Where classified usage goes](https://mintcdn.com/agent-en/tRFRz1weIvYIpDOa/images/techblog/hai-principles/fig1-usage-alluvial.png?fit=max\&auto=format\&n=tRFRz1weIvYIpDOa\&q=85\&s=9e34f451cfaa1c10f1af0482b636f53d)

### 1.2 Human Thought Is Governed by Environment, and the Right Interface Awakens Desire and Intent

This gap is often blamed on users "not knowing how to write prompts," but the failure happens a step earlier: the moment a person opens a blank chat box, they feel no desire to put it to work.

Traditional tool design assumes that a user arrives at software with a crisp, pre-formed intention already in mind. Humans, however, are affective creatures whose train of thought is heavily shaped by their surroundings. Mature consumer software has understood this for decades: shopping apps are designed to feel vibrant and abundant; travel apps are designed to feel inviting and restorative. They are built this way because **the right UI evokes human intent, and only intent produces action**. E-commerce long ago distinguished between *search* and *discovery*: a search bar can only capture **pre-existing intent** already formulated in the user's head, whereas an atmospheric, tactile environment induces **incremental intent**.

J. J. Gibson's theory of *affordance* (1979) and Lucy Suchman's *situated action* (1987) point to the same truth: human plans are rarely conceived inside a mental vacuum and then exported intact; they grow out of seeing concrete objects and responding to environmental cues.

### 1.3 A Single Blank Chat Box Strips Away Environmental Cues and Keeps AI Outside the Workflow

Look at today's chatbots and most agent products: no matter how powerful the toolchain mounted underneath, what greets the user is almost always the same empty input box and blinking cursor.

A foundational law of HCI is *recognition over recall*: humans excel at reacting to concrete visible states, and are remarkably poor at conjuring requirements out of thin air in front of a blank page. Amelia Wattenberger (2023) made the same critique of chat interfaces: a bare text box tells users neither what the system can do nor how to ask. A single, disembodied chat entry flattens all domain texture and sense of place, exerting almost no environmental pull on the user. Confronted with an abstract "How can I help you?", the brain defaults to its lowest-effort habit—treating the system as a search box, or handing it only the few canned chores it has been repeatedly advertised to do. Put differently, a blank box harvests pre-existing intent and creates no incremental intent.

Without an environment capable of awakening intent, even the strongest execution engine sits idle outside the real workflow.

***

## 2. From Delegating Tasks to Delegating Intent

**The question: why are strong engineers growing more exhausted, while some junior practitioners regress into "wishing machines"?**

**Our answer: delegating intent is not delegating a task.** A *task* arrives with its steps and its acceptance criteria already worked out. An *intent* is only a wish for an outcome: state *What*, leave *How* to the machine. What lies between the two is *Why*. An agent does not bear the consequences from which *Why* comes, so it honors only the output contract that a person has written down. The faster the agent, the more that contract matters, and the harder it becomes to learn to write one.

### 2.1 A Real Gulf Separates Task Delegation from Intent Delegation

In 1997, Ben Shneiderman and Pattie Maes famously debated the future of software interaction: Shneiderman argued for visible, predictable *direct manipulation*, where the human remains directly responsible for every action; Maes predicted that software complexity would eventually outgrow the ceiling of manual operation, pushing interaction toward asynchronous *delegation*—humans state goals while interface agents act on their behalf in the background.

Nearly thirty years later, the evolution of programming tools from Cursor to Claude Code and Codex has borne out Maes's prediction. In 2023, Jakob Nielsen framed this shift as the first new UI paradigm in sixty years: moving from *command-based interaction* (specifying *How*) to *intent-based outcome specification* (specifying *What*). In our terms: we used to delegate tasks, and we are now invited to delegate intent.

Yet if "declare *What* and let the machine handle *How*" were the whole story, the corollary would be straightforward: mass unemployment for programmers—and eventually all engineers—would simply be a matter of time.

The labor data are less simple. Tracking payroll records for millions of U.S. workers, the Stanford Digital Economy Lab (Brynjolfsson et al., 2025) reported that by July 2025 employment of software developers aged 22–25 had fallen by nearly 20% from its late-2022 peak, while employment of older age groups in the same occupation continued to grow. The analysis is descriptive, not causal, but it fits what we see around us: routine implementation once handled by junior roles is being absorbed, and the need for experienced judgment is not.

Between *How* and *What*, there remains a stubborn gap that models have not closed.

### 2.2 Software Robustness Still Depends on Humans Defining System Architecture and Testing Contracts

Watching how strong software engineers actually work today makes the shape of that gap unmistakable.

Many of those we work with already hand nearly all concrete code writing to black-box agents, yet strictly keep two responsibilities in their own hands: **framing the problem and system architecture, and defining test suites and CI gates.**

This explains a striking paradox in contemporary software engineering: release cycles are accelerating and codebases are growing heavier, yet production systems remain stable. What holds chaos at bay is not that models have stopped making mistakes, but that humans stand outside the black box enforcing tests, gates, and boundaries. Industry reports point the same way, with caveats. Across its survey sample, the 2024 DORA report estimated that a 25% increase in AI adoption was associated with a 7.2% decrease in delivery stability, and its authors point to fundamentals such as small batches and robust testing. GitClear's analysis of changed lines reported a rising share of code that is reverted or rewritten soon after it is written.

At CHI 2024, Subramonyam et al. termed the cognitive side of this the *gulf of envisioning*: when facing a non-deterministic generative system, stating a vague goal is nowhere near enough—the person must still work out what the task should be, how to instruct the model, and how to judge whether the output meets the goal.

### 2.3 Continuously Monitoring Intent Drift and Contract Validity Amplifies Cognitive Load

In conversations with accomplished engineers who rely heavily on agents, one refrain comes up again and again: **AI has not made work feel lighter; it has made it more exhausting.**

When writing code by hand, design thinking unfolded at the pace of implementation. Now that code generation is nearly instantaneous, engineers save the motor cost of typing only to pour their full mental energy into high-intensity scrutiny: continuously checking whether their intent was stated unambiguously, how far execution has drifted from expectation, and whether existing test contracts still hold. The cost can be large enough to hide from the person paying it: in a 2025 randomized trial by METR with experienced open-source developers working in their own repositories, allowing AI tools made tasks take longer, while the developers themselves believed they had been faster.

This fatigue maps onto existing work in HCI and human factors:

* **Rising metacognitive demands** (Tankelevitch et al., CHI 2024): as operational load drops, the metacognitive burden of self-monitoring, task decomposition, and continuous verification rises. A 2026 study in *Harvard Business Review* calls the cognitive fatigue of overseeing AI "brain fry."
* **Ironies of automation** (Lisanne Bainbridge, 1983): automation takes over routine, tractable work first, leaving humans with what designers could not automate; stripped of hands-on fluency, the human is nonetheless expected to step in as the last line of defense when the system crosses a boundary. Simkute et al. (2024) carry these ironies over to generative AI: the user's role shifts from producing to evaluating, and automation makes easy tasks easier and hard tasks harder.

At the same time, users are splitting toward two extremes. Some carry the load and tire. Others put it down: they type a vague wish, stop asking about intermediate logic and edge conditions, and surrender judgment step by step, regressing into "wishing machines." A CHI 2025 survey of knowledge workers by Microsoft Research and CMU saw the same split: respondents with more confidence in the AI reported less critical thinking, and those with more confidence in themselves reported more. There is an irony in who is now measuring the cost: Maes herself is a co-author of a small 2025 study of essay writing in which the group using a language model showed the weakest neural engagement and struggled to quote what they had just written. The authors call what accumulates *cognitive debt*.

Our own usage suggests how common the second response is. In every office category, more than half of sessions end after a single turn. In lookups, scripted runs and one-shot drafting most do, which is partly by design. But in the categories that are iterative by nature—knowledge artifacts, study and research, business processes—more than half still end after the first prompt. A one-turn session is not a failed one; it can be a satisfied lookup. It does tell us how rarely a first answer is checked, pushed back on, or refined.

![How often office sessions end after one turn](https://mintcdn.com/agent-en/tRFRz1weIvYIpDOa/images/techblog/hai-principles/fig2-one-turn-waffle.png?fit=max\&auto=format\&n=tRFRz1weIvYIpDOa\&q=85\&s=0dea611eee200cefc7a49e3d239449aa)

A colleague who works as a financial analyst once shared an episode that captures this vividly. He was mentoring a graduate intern who repeatedly turned in raw AI-synthesized drafts of dismal usability. Half-jokingly, my colleague remarked: "My agent is smarter at this job than yours—at least mine has my domain Skills baked into it." Missing the irony completely, the intern asked back: "Then why don't you just let me use your agent?"

That reply pierces straight to the illusion of the wishing machine: assuming the gap lies in lacking a pre-configured agent, rather than recognizing that what makes an output usable is the professional judgment behind it—knowing what is right, what is wrong, and where the boundaries sit.

### 2.4 The Gap Between What and How Is Why—and It Is Widening

Returning to the central question: what actually sits inside that gap between *How* and *What*?

The answer is **Why**.

For the same *What*, there can be a hundred working *How*s. Why an agent must take one path and never another rests on business costs, historical baggage, and system-level trade-offs. An agent can describe such a trade-off fluently, but it bears no real-world consequences, so it cannot grow a *Why* of its own and should not be the one to settle it. The only standard it reliably follows is the **output contract** into which humans translate and crystallize *Why*.

Worse still, as agents grow more capable, this *Why* gap is not shrinking—it is widening:

1. **The faster the agent runs, the costlier an omitted contract becomes**: as generating *How* accelerates, any implicit assumption left out of the contract hardens much faster into cross-module faits accomplis and technical debt.
2. **Once humans stop writing How, learning Why gets harder**: historically, engineers built their intuition for *Why* precisely by writing *How* with their own hands and hitting walls along the way. This has now been measured for coding: in randomized experiments, developers who learned a new library with AI assistance ended with weaker conceptual understanding, code reading and debugging, and those who delegated fully learned least (Shen & Tamkin, 2026). When *How* is sealed inside a black box, demand for contract specification peaks at the exact moment the everyday soil that cultivates that judgment erodes.

***

## 3. Should Human-AI Interaction Be Completely Transparent?

**The question: today's agents tend to expose their execution traces—why doesn't that make outcomes more controllable?**

**Our answer: fold the reversible, surface the assumptions.** Showing the process is not the same as giving control. Steps that are reversible belong out of sight. What must be put in front of the person is the set of assumptions the model has made, at key nodes that the interface designer has fixed in advance—not left for the model to notice on its own.

### 3.1 High-Speed Agent Execution Has Rendered Real-Time Raw Transparency Physically Impossible

When large language models first arrived as chat interfaces, token streaming roughly matched human reading speed; watching text appear line by line felt natural. Modern agent systems have shattered that equilibrium.

Mainstream LLM APIs now often stream at 100–200 tokens/s and continue to accelerate; paired with a local terminal and toolchain, an agent can fire off dozens of CLI commands, file mutations, and search queries within a single minute. Average adult silent reading of English non-fiction, meanwhile, is about 238 words per minute (Brysbaert, 2019), which by our own conversion is five or six tokens per second—a gap of well over an order of magnitude.

When an interface still insists on dumping every reasoning trace, command-line flag, and raw return log onto the screen verbatim, "transparency" curdles into its opposite. Media scholars Mike Ananny and Kate Crawford, critiquing the transparency ideal, called this *seeing without knowing*: laying a system's massive internal state bare before the user does not confer comprehension or control. Instead, it offloads the cognitive labor of parsing complexity onto the human—using "we showed you everything" as a disclaimer to mask lazy interaction design.

### 3.2 Over-Exposing Intermediate Details Induces Approval Fatigue and Dulls Error Detection

Intuitively, even if nobody can read every log line, showing as much intermediate detail as possible—and popping up confirmation dialogs on sensitive steps—feels safer than a black box. Empirical research shows the reverse.

In pre-registered randomized experiments with 3,800 participants at CHI 2021, Poursabzi-Sangdeh et al. at Microsoft Research tested how model transparency affects human decision-making. Participants shown a clear, transparent model were actually *less* able to detect and correct its sizable mistakes than participants given a black-box model, seemingly because of information overload. Later work found that explanations alone do not cure over-reliance; interfaces that force a moment of thought at the point of decision do better (Buçinca et al., 2021).

In day-to-day agent use, the same mechanism surfaces as classic *approval fatigue*. When a single task triggers a dozen tool-permission prompts within a minute, human attention depletes after the first few checks, degenerating into muscle-memory clicking or switching straight into "allow all" mode. Peers report the same thing: Anthropic cites approval fatigue as a reason for moving Claude Code toward sandboxing. Paper-thin "human-in-the-loop" gates quickly decay into rubber-stamping under high-frequency noise.

### 3.3 Reversible Safety Guardrails Protect the Floor Without Solving Interaction

Engineers recognized early on that letting agents run arbitrary commands carries real risk, and responded with rigorous safety sandboxes. In MiniMax Code, for instance, the runtime enforces `trash` in place of destructive `rm` commands while silently maintaining background version snapshots so that every local mutation made by the agent can be rolled back at any moment.

Such guardrails are essential—but they solve safety containment, not human-agent interaction.

Rollback guarantees that a mistake will not cause irreversible damage; it does not answer how a human can cheaply understand, steer, and verify a fast-moving agent. If an agent edits dozens of files and explores several dead ends over ten minutes, the user can certainly revert to square one with a click—but figuring out *where the agent currently stands, why it touched those modules, and whether the result can be trusted* still forces a binary choice between blind faith and combing through thousands of log lines. **Operational reversibility does not automatically translate into cognitive controllability.**

### 3.4 Ideal Interaction Folds Reversible Steps Away and Surfaces Model Assumptions at Key UI Nodes

The history of taming complexity in computer science has never been about making low-level execution "more transparent"; it has been about raising the level of abstraction. Nobody today asks a compiler to stream every generated assembly instruction across the screen in real time—once an underlying mechanism is reliable or reversible, exposing low-level mechanics is not transparency; it is a leaky abstraction.

Precisely because reversible guardrails like `trash` and silent version control exist, the vast majority of intermediate searches, file reads, and local trial-and-error inside a workspace become zero-risk internal implementation (*How*). While carrying out those steps, the model is free to make assumptions, and we need not rely on the model to introspectively spot its own bias. What works instead is pre-defining **key nodes** in the workflow through UI design, turning the model's assumptions at those nodes directly into visible, inspectable objects. Our working rule: a key node is a place where several valid results differ in a way the person cares about, where later work will be built on the choice, or where an effect is about to leave the sandbox.

Two classic ideas from early HCI describe the mechanism, and we extend each a step:

* **Calm Technology** (Mark Weiser & John Seely Brown, 1996): good systems move smoothly between the *periphery* and the *center* of human attention. In our reading, routine exploration inside a reversible sandbox belongs in peripheral awareness, stepping into the center of attention only when reaching a designated key node or approaching an irreversible boundary outside the sandbox (such as pushing to a remote repository or invoking an external write API).
* **Seamful Design** (Matthew Chalmers, 2003): neither flooding the screen with raw logs nor sealing everything inside a featureless black box, but revealing *seams* deliberately so that people can use them. We place those seams on the nodes that determine where the outcome goes.

This also resolves an apparent tension with Section 2: if intermediate execution is folded away, does human judgment erode even faster? In practice, staring at a hundred-word-per-second terminal scroll never built anyone's judgment. Fixing the model's assumptions onto structured visual nodes pulls human attention back from policing trivial mechanics and concentrates it on governing overall direction at the moments that matter.

***

## 4. Our Position: Designing AI Applications Around Intent Guidance, Intent Editing, and Intent Execution

**The three answers point to one design.** An AI-native application should give people a middle state between the white box of professional software and the black box of chat: a workspace that evokes intent and a few handles for editing it. It should give agents the opposite: a deterministic substrate that exposes the application's full set of atomic operations. These are two sides of one design.

### 4.1 Human-Facing Interfaces Should Sit Between Pure White-Box and Pure Black-Box, Keeping Only Core Intent-Editing Handles

Many of the tensions above have begun to register across agent products, giving rise to a new generation of agent UI surfaces—such as MiniMax Mini Apps, Claude Artifacts, and Antigravity UI Extensions: a live surface beside the conversation that both the person and the agent can act on.

In our own practice, alongside building the Mini App infrastructure, we designed **3D Design**: the UI provides live 3D previews together with the diagnostic views required for checking a part before printing, while the agent writes modeling scripts in the background, constructs the geometry, and pushes the result straight into the right-hand panel. When the user wants to refine a local feature, they click a point on the 3D surface and describe the change; the agent turns it into a change of parameters, rebuilds the geometry, reruns the checks, and refreshes the viewport.

<video controls playsInline width="100%" poster="/images/techblog/hai-principles/case-study-poster.jpg" src="https://mintcdn.com/agent-en/Os8KFbba6uA87Pau/images/techblog/hai-principles/case-study.mp4?fit=max&auto=format&n=Os8KFbba6uA87Pau&q=85&s=db2e5d4515aa57660c9af7f2bf31b741" />

![The middle state between white box and black box, and the two surfaces behind it](https://mintcdn.com/agent-en/tRFRz1weIvYIpDOa/images/techblog/hai-principles/fig3-middle-state.png?fit=max\&auto=format\&n=tRFRz1weIvYIpDOa\&q=85\&s=bc0848ddce24559cba236986a04b2f9f)

Different agent harnesses converge on the same interface rule: **human-agent interaction belongs neither to the pure white-box of legacy professional software nor to the pure black-box of a generic chat prompt, but to a middle state between them—UI designed around intent guidance and intent boundaries.**

As Ben Shneiderman argued in *Human-Centered AI* (2020), high automation and high human control are not a zero-sum trade-off; Jeffrey Heer (2019) makes a similar case for shared representations that both people and algorithms can act on. Legacy professional software is a pure white-box—high control, zero automation, trapping users inside hundreds of low-level *How* parameters. Early AI chat boxes swung to a pure black-box—high automation, zero control, offering neither environmental cues to spark intent nor handles to correct local drift. Achieving both requires human-agent collaboration anchored on a small set of key nodes—turning the cognitively taxing output contracts (*Why*) of Section 2 into visual boundaries that a person can grasp at a glance and edit at will. Lab results agree: letting people point at objects rather than describe them made editing with a language model faster, with fewer and shorter prompts (DirectGPT, CHI 2024).

### 4.2 Where There Are No Layers and No Tracks

Printing is a friendly case: the physics is fixed and the list of checks is finite. In 3D Design the *Why* is not carried by a sentence typed into a box. It is held jointly by the key nodes on the interface, the tools for acting on them, and the agent, and only four things are kept in front of the person: a declared frame (named parameters and a process profile), checks drawn on the model before anything is handed over, the choices those checks cannot decide, and a handle for pointing. Refactoring a codebase or running a financial due diligence offers no layer stack and no timeline. But none of the four depends on geometry, so the same approach shows how assumptions made at run time can be extracted and turned into something editable.

The third part carries the weight, and it yields a working definition: **an assumption worth surfacing is a choice among alternatives that all pass the checks.** What the checks can decide is *How* and stays folded. What they cannot decide is an open *Why*. The agent is required to record each such choice as it makes it—what it chose, what it rejected, and where it applies—and the interface attaches that record to the place it affects, where it can be flipped.

| | 3D design for printing (shipped) | Code refactoring (how we would carry it over) | Financial due diligence (how we would carry it over) |
| - | - | - | - |
| Declared frame | named dimensions, mounting, printer and material | interfaces and behavior that must not change; the target module boundary | scope, period, accounting basis, materiality threshold |
| Checks before handoff, drawn on the artifact | watertight, fits the machine, bed contact, overhangs, wall thickness | tests, types, compatibility of public interfaces, per file and symbol | ledgers tie to statements; each figure traces to a source document |
| Choices the checks cannot decide | orientation, where support goes, how thick a visible rim is | which of two valid module splits; whether an unused path is dead or reserved | how to classify a one-off item; which adjustment to accept |
| Handle for pointing | a point or a control handle on the surface | a symbol, a call site, a dependency | a line item, a clause, a cell |
| Step that leaves the workspace | export for the slicer | push, publish, migrate | send the report, sign off |

We do not claim this is solved outside verticals. There the set of checks is not closed, so an agent can make a choice that no check sees. Our working answer has two halves: treat every recurring surprise as a missing check to be built, and have the agent declare its choices as it makes them instead of hoping to detect them afterwards.

The older examples fit the same pattern. In photo editing the **layer** is the handle and in video editing the **track** is; tone curves and transitions can fold because checks or cheap undo cover them. Some worry that folding such fine-grained controls will flatten creative taste and "craft." It will not. Fine-tuning local parameters is ultimately execution craft, and models will keep getting better at it. Human attention is most scarce and irreplaceable in maintaining holistic coherence—knowing that harmony works most of the time, yet in a particular piece, *tension* or *conflict* is the exact aesthetic point. Expressing taste requires knowing where the entry point for intent lives, and pointing at the place where that tension belongs.

### 4.3 Our Product Signals Point the Same Way

We compared sessions that began in a Mini App with sessions that began in the closest baseline we have for the same vertical: plain chat, a one-shot generator, or a headless tool with no workspace. Three signals point in the direction our position predicts:

* **Continuing.** In every vertical we compared, sessions were more likely to continue past the first turn with the Mini App. We read this as the environment doing what Section 1 asks of it: a panel with visible objects makes people want to explore further and go deeper into the work. That is incremental intent, formed after the session began.
* **Friction.** Among sessions that did continue, the share with explicit negative feedback was lower with the Mini App in all seven verticals. The size of the drop varies a good deal from one vertical to another.
* **Balance.** In plain chat, people who say anything mostly complain. With Mini Apps the balance of complaints to praise moved toward even in all seven verticals, and in two it reached rough balance.

![Directional signals from matched comparisons, by broad vertical](https://mintcdn.com/agent-en/tRFRz1weIvYIpDOa/images/techblog/hai-principles/fig4-miniapp-signals.png?fit=max\&auto=format\&n=tRFRz1weIvYIpDOa\&q=85\&s=b31635e025cfce0abbaef0302119f9a6)

### 4.4 Agent-Facing Substrates Must Reject Fuzzy Wrappers and Expose Full Atomic Business Permissions

Once the human-facing interface converges onto a minimal set of contract handles, how should the underlying software substrate be designed for the agent so that upstream intent and contracts land reliably?

From past practice, the worst retrieval pattern in the agent era is vector-similarity retrieval over text chunks (naive RAG) used as the agent's only way into a body of business documents—because it tangles *business understanding* with *execution logic*. When a user needs specific information, it cannot enforce exact constraints over ownership, tags, keywords, or sentiment; it forces the agent to guess business structure from fuzzy fragments. When that guess feeds the next retrieval query, the agent compounds one ungrounded guess on top of another, turning task completion into a game of roulette. In that production system, the problem was only truly solved once we handed precise, structured querying and filtering to the agent (we used Elasticsearch). Similarity search keeps its place for open-ended recall; our point is about who holds the predicates.

That lesson generalizes: as the executor of delegated intent, the agent's real job is **translating business understanding into execution logic**, and the substrate on which it executes makes all the difference. Precisely because model reasoning is probabilistic, the tools and permission primitives beneath its feet must be deterministic, transparent, and fine-grained—the agent needs access to the software's full set of atomic business permissions.

In this respect, `lark-cli` and its accompanying Skill ecosystem are the best example we know. Rather than wrapping an office suite inside a crippled chat sidebar, it decomposes documents, spreadsheets, multidimensional tables, calendars, approvals, and raw OpenAPIs into permission-scoped, composable atomic commands, guided by Skills for agent orchestration. The commands also encode reversibility: mail commands save a draft by default and send only with an explicit confirmation flag, so the irreversible step is the one that surfaces. Skills, for their part, package reusable *How*. They do not carry the *Why*—which is why borrowing a colleague's agent does not make an intern's output usable.

**Converging interface controls for humans while opening full atomic business permissions to agents are two sides of the same coin in AI-native software.**

### 4.5 Future AI Application Design Should Center on Intent Guidance, Intent Editing, and Intent Execution

Bringing these threads together, the design of future AI applications comes down to three pillars:

1. **Intent Guidance**: Move beyond the cold, solitary blank input box; use domain-textured workspaces and concrete visible objects to awaken desire, so that incremental intent grows naturally out of context instead of waiting for pre-existing intent to walk in.
2. **Intent Editing**: Build a middle ground between pure white-box and pure black-box—fold reversible execution away and keep four things in view: the declared frame, the checks drawn on the artifact, the choices the checks cannot decide, and a handle for pointing such as a point in space, a layer, or a track, so humans can specify and revise contracts at low cognitive cost.
3. **Intent Execution**: Provide a deterministic execution substrate that refuses to blur business understanding into fuzzy wrappers—hand the agent exact queries, and expose full atomic business permissions as `lark-cli` and Skills do, so agents can reliably turn human intent into finished outcomes.

***

## 5. Objections We Take Seriously

**"Better models will make the box enough."** With memory, initiative and better inference of intent, an agent may supply the context that the blank box lacks. This is the objection we watch most closely. Our answer is that a model can only guess what a person might want from what both can see, and a suggestion offered at the right moment is itself an environmental cue, which is our answer in Section 1. We would change our minds if depth of use outside coding rose in products that kept a bare box and changed only the model.

**"Folding is opacity."** For audit, the trace is the record; for a learner, it is the lesson. We agree, and folding is not deletion: the trace stays available on demand and irreversible steps always surface. What we oppose is the raw trace as the default surface of interaction.

**"Key nodes fixed in advance do not scale."** This is the largest gap in our argument, and Section 4.2 is our answer so far: a declared frame, checks before handoff, and a rule for what to surface. Reviewing a plan before execution—as in Magentic-UI's co-planning and the plan modes of coding agents—surfaces assumptions once, at the start, and misses those made in mid-run. What remains open is the choice that no existing check can see.

**"Some parameters are the intent."** A colorist's grade is not mechanics. We agree that a parameter can carry intent. Our claim concerns where intent is expressed: at a structural handle, by pointing and by saying why, rather than by owning every slider. Experts should always be able to unfold. We may be wrong for crafts in which the control itself is the tool for thinking.

**"Atomic permissions enlarge the blast radius."** They can. Fine-grained commands also allow narrower grants per task than a monolithic wrapper, and they let the irreversible ones be singled out. A hijacked agent with full atomic access remains a serious risk that interface design does not remove.

**"Your evidence is weak."** It is observational: people chose to open a Mini App, baselines are the closest available and not controls, and corrections that move from typed messages to direct manipulation will lower typed complaints by themselves. We rely on the sign agreeing in every comparison, not on any one of them.

**"More turns are not better."** We agree: turn count is a double-edged measure. More turns can mean that the panel has drawn the person into exploring and into deeper work, which is how we read Figure 4(a). But when a person stops also matters: stopping early because the result is already satisfactory is a sign that the tool and the model are doing their job. The Finance row shows both edges. Against plain web search the panel continues more often. In a separate cut of our logs, restricted to financial research and compared with headless data tools, it continues less often; our reading is that people reach what they wanted sooner. So we read continuation together with the friction signals, which say whether the extra turns were refinement or repair.

**"Folding How starves the learning of Why."** We have no full answer. Scrolling logs did not teach either, but something did, and it was writing *How* by hand. Deliberate unfolding for learners, and moments of forced thought at key nodes, are directions and not solutions.

***

## 6. Questions for Peers

1. **Depth of use.** Is the lookup-and-one-off pattern outside coding universal? If your product moved it, what moved it: the model, memory, or the surface?
2. **Finding key nodes.** We surface choices that pass every check. How do you decide what to surface, and has anyone had an agent declare its own assumptions reliably at run time?
3. **A catalogue of handles.** Points, layers and tracks are ours. What are the minimal handles in your domain, and could we assemble a shared catalogue?
4. **Measures.** Turn counts and typed feedback are poor proxies. What do you use instead? Could products agree on a small set of directional indicators that can be shared without disclosing volumes?
5. **Growing judgment.** How do you keep less experienced people learning *Why* when *How* is folded?
6. **Substrates.** Which of your product's operations are exposed to agents as atomic, permission-scoped commands? Where did structured queries beat similarity search, and where did they not?

***

## Closing

The contract of explicit command and immediate feedback does not survive an agent that plans, acts and changes the world at machine speed. Our response has three parts. Give people an environment in which intent can form. Give them a middle state in which to edit it, with the reversible folded away and the model's assumptions made visible at a few chosen nodes. And give the agent a deterministic substrate on which to carry it out.

Two sentences carry most of what we have learned: operational reversibility does not translate into cognitive controllability, and once people stop writing *How*, *Why* gets harder to learn.

We hold this position on the strength of practice and of signals that point one way. We would rather have it tested by peers than agreed with.

***

## References

* Ananny, M. & Crawford, K. (2018). [Seeing without Knowing](https://doi.org/10.1177/1461444816676645). *New Media & Society*, 20(3).
* Anthropic (2025). [Making Claude Code Safer with Sandboxing](https://www.anthropic.com/engineering/claude-code-sandboxing).
* Bainbridge, L. (1983). [Ironies of Automation](https://doi.org/10.1016/0005-1098\(83\)90046-8). *Automatica*, 19(6).
* Becker, J., Rush, N., Barnes, E. & Rein, D. (2025). [Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity](https://arxiv.org/abs/2507.09089). METR.
* Bedard, J. et al. (2026). [When Using AI Leads to "Brain Fry"](https://hbr.org/2026/03/when-using-ai-leads-to-brain-fry). *Harvard Business Review*.
* Brynjolfsson, E., Chandar, B. & Chen, R. (2025). [Canaries in the Coal Mine?](https://digitaleconomy.stanford.edu/publications/canaries-in-the-coal-mine/) Stanford Digital Economy Lab.
* Brysbaert, M. (2019). [How Many Words Do We Read per Minute?](https://doi.org/10.1016/j.jml.2019.104047) *Journal of Memory and Language*, 109.
* Buçinca, Z., Malaya, M. B. & Gajos, K. Z. (2021). [To Trust or to Think](https://doi.org/10.1145/3449287). *PACM HCI*, 5(CSCW1).
* Chalmers, M. & MacColl, I. (2003). Seamful and Seamless Design in Ubiquitous Computing. UbiComp 2003 Workshop.
* Chatterji, A. et al. (2025). [How People Use ChatGPT](https://www.nber.org/papers/w34255). NBER Working Paper 34255.
* DORA (2024). [Accelerate State of DevOps Report 2024](https://dora.dev/research/2024/dora-report/).
* Gibson, J. J. (1979). *The Ecological Approach to Visual Perception*. Houghton Mifflin.
* Harding, W. & Kloster, M. (2024). [Coding on Copilot](https://www.gitclear.com/coding_on_copilot_data_shows_ais_downward_pressure_on_code_quality). GitClear.
* Heer, J. (2019). [Agency plus Automation](https://doi.org/10.1073/pnas.1807184115). *PNAS*, 116(6).
* Kosmyna, N. et al. (2025). [Your Brain on ChatGPT](https://arxiv.org/abs/2506.08872).
* Lee, H.-P. et al. (2025). [The Impact of Generative AI on Critical Thinking](https://doi.org/10.1145/3706598.3713778). CHI '25.
* Masson, D. et al. (2024). [DirectGPT](https://doi.org/10.1145/3613904.3642462). CHI '24.
* Mozannar, H. et al. (2025). [Magentic-UI: Towards Human-in-the-loop Agentic Systems](https://arxiv.org/abs/2507.22358).
* Nielsen, J. (1994). [Enhancing the Explanatory Power of Usability Heuristics](https://doi.org/10.1145/191666.191729). CHI '94.
* Nielsen, J. (2023). [AI: First New UI Paradigm in 60 Years](https://www.nngroup.com/articles/ai-paradigm/). Nielsen Norman Group.
* Poursabzi-Sangdeh, F. et al. (2021). [Manipulating and Measuring Model Interpretability](https://doi.org/10.1145/3411764.3445315). CHI '21.
* Shen, J. H. & Tamkin, A. (2026). [How AI Impacts Skill Formation](https://arxiv.org/abs/2601.20245).
* Shneiderman, B. (2020). [Human-Centered Artificial Intelligence: Reliable, Safe & Trustworthy](https://doi.org/10.1080/10447318.2020.1741118). *IJHCI*, 36(6).
* Shneiderman, B. & Maes, P. (1997). [Direct Manipulation vs. Interface Agents](https://doi.org/10.1145/267505.267514). *Interactions*, 4(6).
* Simkute, A. et al. (2024). [Ironies of Generative AI](https://arxiv.org/abs/2402.11364).
* Subramonyam, H. et al. (2024). [Bridging the Gulf of Envisioning](https://doi.org/10.1145/3613904.3642754). CHI '24.
* Suchman, L. A. (1987). *Plans and Situated Actions*. Cambridge University Press.
* Tankelevitch, L. et al. (2024). [The Metacognitive Demands and Opportunities of Generative AI](https://doi.org/10.1145/3613904.3642902). CHI '24.
* Wattenberger, A. (2023). [Why Chatbots Are Not the Future](https://wattenberger.com/thoughts/boo-chatbots).
* Weiser, M. & Brown, J. S. (1996). Designing Calm Technology. *PowerGrid Journal*, v1.01.
