Interaction for Provisional Computing

Summary

Most interfaces present computation as a sequence of settled transitions: issue a command, receive a result, continue from the new state. Yet much consequential computing is not settled when it first becomes useful. A design may have several promising variants; an AI output may be plausible but unverified; an agent may have begun a plan whose later actions should remain interruptible; a program may be executable while parts remain unspecified. In each case, the system has produced something actionable before finality.

This review calls that condition provisional computing: computation whose inputs, interpretations, processes, outputs, or effects remain explicitly open to inspection and revision. The HCI challenge is not merely to visualize uncertainty. It is to preserve useful openness without making users manage the machinery of openness. The strongest prior systems make provisional states into manipulable objects: previews can persist; alternatives can be compared and edited in parallel; histories can branch; uncertain suggestions can be scoped, corrected, or declined; evidence can be inspected at the point of a claim.

The evidence does not support a universal prescription to show more alternatives, more confidence numbers, or more internal reasoning. Parallel alternatives can improve exploration and outcomes, but can also impose setup and comparison costs. Confidence displays sometimes improve reliance calibration, but their effects depend on representation, task, and users’ own judgments. Explanations can increase reliance on correct and incorrect advice. The design target is therefore not maximum transparency. It is calibrated legibility: enough structure to support an appropriate next action.

1. Scope and review method

The review is integrative rather than systematic. It begins with the Cognitive Dimensions concept of provisionality and follows direct conceptual descendants—especially Lunzer and Hornbæk’s subjunctive interfaces—then samples adjacent HCI traditions that operationalize reduced commitment: persistent previews, parallel authoring, branching histories, undo, ambiguity-preserving design tools, live and incomplete programming, mixed-initiative interaction, uncertainty visualization, and recent human–LLM interfaces.

Sources were selected when they contributed at least one of four things: a conceptual vocabulary for tentative action; an interaction mechanism that keeps computation revisable; empirical evidence about consequences for users; or a caution about reliance, effort, and agency. Priority was given to peer-reviewed primary papers and durable author copies. Recent preprints are included only where they extend the interaction space faster than archival publication, and are marked by venue status in the references.

The scope is interactional, not computational. Speculative execution, optimistic concurrency, probabilistic inference, incremental computation, and versioned storage matter insofar as they enable an experience of provisionality. A backend can speculate while exposing a conventionally final interface; conversely, a Wizard-of-Oz prototype can create a genuinely provisional interaction without sophisticated machinery. The unit of analysis is the relationship among user, representation, and possible future states.

2. What is provisional computing?

The Cognitive Dimensions framework names provisionality as the degree to which users can try things out and defer commitment. Green and Petre treat it as one of several dimensions through which information artifacts impose cognitive costs; it counterbalances premature commitment, where the system forces a decision before the user has the information needed to make it well.1 Lunzer’s early account of subjunctive interfaces makes the link explicit: when an application normally demands one value, an interface can instead allow several values to coexist as alternative “realities,” making tentative rather than firm decisions acceptable.2

That foundation suggests a definition:

Provisional computing is an interaction condition in which some computational state is useful and available now while its meaning, validity, continuation, or effects remain explicitly non-final.

The definition is deliberately relational. Nothing is provisional in isolation. A draft becomes provisional because a later state is anticipated and revision remains possible; a prediction becomes provisional because evidence, model uncertainty, or user judgment can still change how it is treated; an agent action becomes provisional because execution and commitment have been separated.

Four dimensions of provisionality

These dimensions can overlap but should not be collapsed. A generated draft may be epistemically uncertain yet safe to edit; a correctly inferred bank transfer may be epistemically certain but consequentially uncommitted. Confidence is relevant to the first case, confirmation to the second. Treating all provisionality as “AI uncertainty” produces the wrong controls.

A state model: branch, inspect, revise, commit

Across the literature, provisional interaction repeatedly separates four operations. Branch creates or preserves alternatives. Inspect exposes their content, evidence, dependencies, or likely effects. Revise changes one or several alternatives without destroying the point of comparison. Commit promotes a provisional state into an authoritative or consequential one. Undo and repair form a fifth, post-commit path when commitment must be revisited.

This is not necessarily a visible workflow. Glimpse, for example, embeds preview and commit/cancel into pressure-sensitive input so that exploring an edit requires almost no mode switch.3 At the other extreme, branching version histories make alternatives explicit, persistent objects. The appropriate visibility depends on stakes, duration, number of alternatives, and the cost of reconstructing context.

3. Intellectual lineage

Provisionality, ambiguity, and incremental formalization

Early design-system research recognized that ambiguity is often a resource rather than a defect. Gross and Do’s Electronic Cocktail Napkin retained multiple interpretations of rough drawings, represented imprecision through constraints, and supported movement from sketchy to formal representations.4 Their key interaction claim is still current: if ambiguity or imprecision exists in a person’s work, the system must be able to represent it internally and express it in output and behavior. Silently resolving ambiguity creates false finality.

Prorogued programming applies the same logic to executable software. A programmer can defer an unimplemented concern, run the partial program, and supply values at runtime; the system stores these examples while the implementation is gradually reified.5 This is provisionality across temporal and epistemic dimensions: the program is useful enough to test while visibly incomplete. It also demonstrates a recurring risk—if unresolved calls prompt too often, the human becomes a blocking peripheral for the computation rather than its director.

Subjunctive interfaces and parallel alternatives

Subjunctive interfaces provide the clearest ancestor for the present synthesis. Instead of serially trying one parameter setting and remembering its result, users establish multiple scenarios, inspect them together, and control common or differing values. In three studies, Lunzer and Hornbæk found benefits that emerged with design refinement and learning: an initial study improved satisfaction but not completion time; after five sessions with a redesigned interface, users completed tasks 27% faster than with a simple interface. In open-ended exploration, scenarios became “information holders” that users repurposed to support reasoning.6

Several systems specialize this principle. Side Views make command previews persistent and dynamic, supporting comparison, what-if exploration, and serendipitous alternatives without altering source data.7 Parallel Paths elevates variations into first-class objects that can be created at the moment a promising preview appears and then edited together where they remain similar.8 Juxtapose adds selectively parallel editing and execution to interface code, plus generated controls for tuning parameters at runtime; a study with 18 participants found that designers could survey more options faster.9

Controlled prototyping studies strengthen the case for plurality while clarifying its mechanism. Dow and colleagues found that novice designers who created prototypes in parallel produced more diverse and better-rated outcomes and reported greater task-specific self-efficacy than those iterating serially.10 In collaborative work, sharing multiple designs improved exploration, critique, rapport, integration of partners’ ideas, and outcome quality compared with sharing one or only the best design.11 Multiple artifacts redistribute psychological investment: critique becomes a comparison among possibilities rather than a verdict on a single precious answer.

History, reversibility, and versions as material

Undo is often described as recovery, but for provisional computing its deeper role is to reduce the anticipated cost of exploration. Linear undo is a weak form: it allows retreat but makes divergent futures overwrite one another. Branching histories preserve alternatives and the points at which they diverged. Data-exploration systems with tree-structured histories were motivated by exactly this limitation: linear histories force users to recognize branch points mentally and compare states from memory.12

Selective undo exposes another requirement: revision must respect dependencies. An empirical comparison found that participants preferred dependency-aware cascading selective undo over purely linear or script-selective models in the studied application.13 A provisional interface therefore needs more than saved snapshots. Users require intelligible lineage, scope, and propagation: if a common edit is made, which branches inherit it? If an earlier step is removed, what downstream states become invalid?

Quickpose reframes version control as material interaction. In a small longitudinal study with three creative coders, versions and annotations formed a spatial canvas for building local knowledge through comparison, contextualizing states, and revisiting work.14 The important shift is from history as backup to history as a manipulable thinking material. This also explains why exhaustive logging can be inferior to meaningful capture: a useful history preserves distinctions people can interpret, not every technically available state.

4. Interaction patterns for provisional systems

The literature yields a family of patterns rather than one canonical interface. These patterns can be combined, but each carries a management cost.

1. Mark status in the representation, not only in metadata

A provisional object should look and behave differently from a committed one. Rough rendering, ghosted geometry, bounded regions, labels such as “draft” or “awaiting verification,” and distinct placement can all preserve status. The signal must survive copying, sharing, and later return. A banner above an otherwise authoritative-looking answer is fragile; claim-local cues are harder to detach from what they qualify.

2. Preview both action and outcome

Feedforward communicates what can happen before action, complementing feedback after it. In VR, Muresan, McIntosh, and Hornbæk map a design space in which a trigger reveals a preview of actions and outcomes and then restores the environment; expert evaluation produced 15 guidelines for applying the technique.15 For provisional systems, preview should include not only the output but its scope: what objects, data, people, or external systems would be affected.

3. Let alternatives persist, align, and differ visibly

Transient previews help answer “what will this command do?” Persistent alternatives support “which direction should I pursue?” Once alternatives persist, the interface must coordinate them: align comparable attributes, highlight differences, propagate shared edits, and let users name or annotate why a branch matters. Without these operations, users trade memory burden for branch-management burden.

4. Keep local edits local—and make propagation deliberate

Provisional work often mixes stable and unsettled regions. DirectGPT demonstrates the value of selecting output objects and applying a prompt only to them, turning physical selection into an explicit noun while the prompt supplies the verb. In a study, participants were 50% faster and used 50% fewer and 72% shorter prompts than a baseline chat interface for editing text, code, and vector graphics.16 Its operation-granular undo further keeps generated changes reversible.

5. Separate generation, validation, and commitment

A system may compute a candidate quickly, verify it slowly, and commit it only after a policy or person accepts it. Keeping these phases distinct allows latency to become useful time for inspection. But the interface must avoid presenting downstream work based on an invalid branch as if it were authoritative. Interactive Speculative Planning addresses this with a rescheduling layer that serializes asynchronous approximate and target-agent outputs, and allows people to interrupt slow or unsatisfactory steps.17

6. Put evidence beside the claim it qualifies

Provenance is operational when users can move cheaply from a claim to its support. Generic source lists demand search; claim-local citations, excerpts, and page references reduce the cost of verification. The placement also expresses granularity: evidence supports this sentence or region, not necessarily the entire response. Recent scholarly-Q&A work such as PaperTrail goes further by matching claims to evidence and indicating both unsupported answer claims and source claims omitted from the answer.18

7. Make the commit boundary perceptible

A commit control should say what becomes durable or externally visible. High-impact actions may benefit from a review surface that summarizes unresolved items, changed scope, evidence gaps, and downstream effects. Low-impact creative exploration should avoid repeated confirmation. The threshold should scale with consequence and reversibility, not with how “intelligent” the system appears.

5. Provisional computing in human–AI interaction

AI systems make provisionality unavoidable because their outputs are inferential, variable, and often fluent enough to appear more settled than they are. The classic mixed-initiative literature already frames the core allocation problem: automated services should interleave with direct manipulation, reason about uncertainty in user goals, choose when to act or ask, and “do less, but do it well” as uncertainty grows.19 Twenty years later, Amershi and colleagues synthesized 18 human–AI interaction guidelines, including making clear what the system can do, supporting efficient correction, remembering recent interactions, and scoping services when in doubt.20

From answer boxes to editable intermediate objects

Conversation makes revision available in principle—users can always type another turn—but leaves scope and state implicit. Newer interfaces externalize intermediate structure. Interactive Reasoning represents generated reasoning as an editable hierarchy whose nodes can be added, changed, removed, regenerated, and connected to response sentences; a 16-participant study found that this helped participants identify and interrupt errors, steer responses, and understand outputs.21 The interaction move is more general than exposing chain-of-thought: decompose a provisional result into inspectable units and let local interventions update the whole.

Grounding interfaces address provisionality on the input side. Liu and colleagues compared provisional completion, multiple suggested inputs, and structured input guidance with an ungrounded natural-language baseline (N=80). Grounded variants reduced cognitive load and improved task performance; structured grounding also reduced speaker-change costs without reducing perceived control.22 Instead of demanding a perfect prompt, the interface helps user and system progressively establish a shared specification.

Uncertainty is useful only when actionable

Displaying a probability does not automatically support judgment. Cao, Liu, and Huang compared no confidence, raw probability, calibrated probability, and calibrated-frequency presentations in AI-assisted decision tasks. Only calibrated frequency was associated with participants regulating reliance according to model uncertainty.23 A separate visualization study found ordinal uncertainty more likely to calibrate model-use behavior, with effects shaped by task difficulty and model uncertainty.24

Recent LLM studies make the warning sharper. Kim and colleagues found that explanations increased reliance on both correct and incorrect answers, while sources and visible inconsistencies reduced reliance on incorrect answers in a preregistered experiment (N=308).25 Bo, Wan, and Anderson’s preregistered study (N=400) found that several interventions reduced over-reliance largely by reducing reliance overall; they did not reliably improve appropriate reliance, and some imposed time or subjective-experience costs.26

6. Design tensions

Openness vs. management overhead

Every preserved alternative creates an object to identify, compare, update, or discard. Subjunctive-interface studies show that scenario setup and control can erase efficiency gains; versioning work repeatedly encounters scale and retrieval problems. Systems should therefore support progressive pluralization: begin with one visible path, preserve branch points cheaply, and expand alternatives when disagreement, uncertainty, or user intent warrants it.

Legibility vs. false authority

A neat confidence badge or explanation can make an output seem more scientific without making it more reliable. Legibility must preserve the distinction among model confidence, empirical accuracy, evidence quality, and system status. Where no calibrated probability exists, categorical statements such as “awaiting source verification” may be more honest and actionable than a fabricated percentage.

Agency vs. interruption burden

Human approval is not synonymous with human control. Repeated prompts can make people rubber-stamp decisions, fragment attention, and transfer clerical work from machine to person. Mixed-initiative systems should request input when the user has relevant information, values are genuinely at stake, or errors would be expensive—not whenever the system can formulate a question.

Reversibility vs. meaningful consequence

Undo encourages exploration, but some interactions are physically, socially, or temporally irreversible. Rossmy and colleagues deliberately study irreversibility as an HCI design material, showing how consequence can support reflection and meaningful action while also redistributing power and responsibility.27 A provisional interface must not imply rollback where only compensation is possible. “Refund,” “publish correction,” and “send another message” are not undo.

Fluidity vs. accountability

Ephemeral drafts make exploration safe; durable records make consequential decisions auditable. Systems can support both by retaining lightweight lineage privately during exploration, then generating a structured decision record at commitment: selected branch, rejected alternatives where relevant, unresolved caveats, evidence used, and responsible actor.

Parallelism vs. coherent presentation

Asynchronous agents and speculative backends can reduce latency, but raw completion order is not a coherent explanation of process. Interfaces need a causal presentation layer that distinguishes predicted, running, verified, invalidated, and committed work. Otherwise speed comes at the cost of a false mental model.

7. A framework for design: the provisional contract

A useful interface establishes a provisional contract—a perceivable agreement about status, control, and consequence. Designers can specify it with seven questions:

A practical pattern language

Match mechanism to stakes

Low-stakes, easily reversible interactions benefit from immediate previews and lightweight undo. Moderate-stakes work benefits from persistent alternatives, annotations, and clear scope. High-stakes or externally visible actions need evidence, role clarity, explicit commitment, and an honest repair path. The interface should become more deliberate with increasing consequence—not merely with increasing model uncertainty.

8. How should provisional interaction be evaluated?

Task time and final accuracy are necessary but insufficient. Provisional systems aim to change the path by which people explore and commit. Evaluation should therefore measure process, judgment, and downstream consequences.

Study designs should include cases where the provisional result is right and wrong, where uncertainty is high and low, and where the user’s initial judgment is right and wrong. Without this factorial structure, a system that encourages blanket skepticism can masquerade as one that supports appropriate reliance. Longitudinal studies are especially important because branch organization, naming, and history practices become meaningful over time.

9. Research agenda

Provisionality across time scales

Current work often studies seconds-long previews or session-scale alternatives. Less is known about states that remain provisional for weeks: evolving analyses, policy drafts, long-running agent plans, or machine-generated knowledge bases. Research should examine decay, ownership, reminders, and criteria for retiring unresolved branches.

Group provisionality

In collaborative systems, provisional status may differ by person: an author sees a draft, a reviewer sees a proposal, and an automation treats it as input. Future work should model permissions to branch, merge, endorse, contest, and commit—and make disagreement visible without forcing premature consensus.

Semantic merge for generated artifacts

Version control can merge text syntactically, but provisional AI work often requires semantic reconciliation: combine the evidence discipline of one answer with the structure of another, or retain a local edit while regenerating its surroundings. Interfaces need inspectable merge proposals and explicit policies for what the model may rewrite.

Adaptive interaction cost

The right amount of oversight changes with stakes, user expertise, system history, and current uncertainty. Adaptive systems might surface more comparison when models disagree, more provenance when claims are consequential, and fewer confirmations after stable patterns emerge. Such adaptation itself must remain legible and user-correctable.

Beyond confidence to sources of provisionality

Interfaces should communicate whether uncertainty arises from ambiguous intent, sparse evidence, disagreement among methods, distribution shift, unstable generation, or an incomplete process. These sources suggest different actions. A useful research program would compare source-specific controls against generic confidence displays.

Commitment as a first-class HCI object

HCI has rich accounts of action, feedback, undo, and trust, but less consolidated language for how tentative work becomes authoritative. Agentic systems make this gap urgent. We need taxonomies of commitment, empirical studies of commit boundaries, and patterns for repair when an effect cannot be reversed.

Conclusion

Provisional computing is less a new species of system than a way of seeing a recurring interaction condition. Computation often becomes useful before it becomes final. Good interfaces do not hide that gap, collapse it prematurely, or make users administer every uncertainty. They turn selected aspects of openness into workable material.

The deepest lesson from subjunctive interfaces, parallel prototyping, persistent previews, branching histories, and mixed-initiative systems is that uncertainty becomes manageable through structure: alternatives that can be aligned, claims that can be traced, edits that can be scoped, states that can be revisited, and commitments that can be recognized. The goal is not permanent tentativeness. It is to let people remain tentative exactly as long as the work requires—and then cross into consequence with their eyes open.