Blog · Review Essay · Last reviewed June 25, 2026

Computers as Theatre and the Stage Called Interface

Brenda Laurel's Computers as Theatre gives interface design a language that still feels more exact than much AI product talk. The computer is not only a tool, dashboard, database, or channel. It is a staged situation in which people, software, roles, goals, emotions, constraints, and possible actions meet over time.

The sharper AI-era claim is that an interface is not a skin around a model. It is the scene where authority is assigned, trust is cued, action is made legible, and exit is either preserved or quietly made expensive.

For this review, a stage inventory is the practical audit of that scene: actor, audience, role, props, script, offstage machinery, permissions, memory, record, affected third parties, and exit. The governance problem is not whether software is literally theatrical. It is whether a product can script action, dependence, disclosure, or consent while appearing to merely help.

The Book

Computers as Theatre first appeared with Addison-Wesley in 1991, when personal computing, graphical interfaces, video games, virtual reality, and network culture were still taking shape as everyday media. ACM's Guide to Computing Literature records the original edition as a 211-page Addison-Wesley book published in January 1991, while Pearson/Addison-Wesley sample pages identify the second edition with ISBN-13 978-0-321-91862-8 and a September 2014 first printing.

Laurel's authority comes from the unusual combination the book performs. Pearson's author note says she had worked in interactive media since 1976 and moved through games, interface design, virtual reality, research, teaching, and entrepreneurship, including Atari, Activision, Apple, Telepresence Research, Purple Moon, Sun Microsystems Labs, California College of the Arts, Art Center, and UC Santa Cruz. WIRED's 1993 profile places her directly inside early debates about cyberspace, VR, interactive entertainment, and who computer interfaces include or exclude.

The book's premise is simple enough to sound like a metaphor and deep enough to become a design method: interactive software should be understood through dramatic action. A human-computer interaction is not just a person operating a mechanism. It is a live arrangement of agency, representation, timing, convention, feedback, expectation, and consequence.

Current Context

As of June 25, 2026, Laurel's theatrical frame maps cleanly onto the governance vocabulary now forming around generative AI and agents. NIST's Generative AI Profile was published in July 2024 and updated in April 2026; it treats "Human-AI Configuration" as a risk category that includes inappropriate anthropomorphizing, automation bias, over-reliance, and emotional entanglement. NIST's 2026 AI Agent Standards Initiative separately frames agent identity, authentication, interoperability, and security evaluation as standards problems.

The policy context has also moved from metaphor to obligation. EU AI Act Article 50 requires notice for many direct AI interactions and marking or disclosure duties for many synthetic outputs; Article 113 sets the Act's general application date at August 2, 2026, with some provisions applying earlier or later. The European Commission's June 10, 2026 transparency code is voluntary as a code, but it is meant to support compliance with Article 50's legal obligations around marking and labelling AI-generated content.

The Digital Services Act adds a platform-design layer. Article 25 prohibits online platforms from designing, organizing, or operating interfaces in ways that deceive, manipulate, or materially impair free and informed decisions, while Article 27 requires plain-language recommender-system parameter information and available user options. That matters for Laurel because the interface is where a choice becomes a performance: the system can make one path feel natural, another feel dangerous, and a third disappear.

The result is a more concrete reading of the book. Interface staging is no longer only an aesthetic or usability concern. It is where a system's role, authority, memory, synthetic status, tool permissions, accessibility, and off-ramp become visible or disappear.

The Interface as Stage

The ordinary interface story treats the screen as a surface. Buttons, windows, menus, chat boxes, search bars, and dashboards are evaluated by clarity, efficiency, visual hierarchy, accessibility, and task completion. Those things matter. Laurel's contribution is to insist that they do not exhaust the experience. A person using software is not merely reading a screen. They are entering a situation.

A stage has roles. A stage has props. A stage has timing. A stage has offstage machinery. A stage has conventions that tell the participant what kind of action is possible and what kind of meaning an action will carry. That vocabulary fits digital systems better than the old desktop metaphor. A file picker is a prop table. A permission prompt is a threshold scene. A progress bar manages suspense. A notification interrupts the plot. A chatbot persona gives the system a character role before the user has decided whether that role is deserved.

The sharper definition is this: an interface is a staged contract for action. It assigns parts, arranges evidence, decides what appears onstage, hides backstage machinery, and teaches the user which actions are normal, risky, reversible, or impossible. In an AI product, the prompt box, voice, avatar, memory panel, citation drawer, permission prompt, and escalation path are not decorative. They are the scene in which authority is produced.

That definition makes the stage auditable. Inspect the cast, the props, the script, the offstage machinery, the audience, the exits, and the record. In software terms: who or what is allowed to speak, what data and tools enter the scene, which defaults steer the next move, which logs and model memories persist afterward, who else is affected, and how a person can pause, appeal, reverse, or leave.

The most important distinction is between theater as presentation and theater as constraint. A good interface can stage complexity so people can act with confidence. A bad one stages complexity so people confuse confidence with permission. The audit question is therefore not whether the scene is smooth. It is whether the smoothness preserves evidence, alternatives, and responsibility.

This makes Computers as Theatre a natural companion to Interface Culture, The Interface Effect, Hamlet on the Holodeck, and The Presentation of Self in Everyday Life. Each book pushes past the idea that media simply carry content. Interfaces organize conduct. They teach people who they are supposed to be while the system is running.

Action, Not Screen

Laurel's theatrical frame is strongest when it moves design attention from static display to unfolding action. The important unit is not the isolated screen, but the whole arc of an interaction: what the user wants, what the system appears to want, what actions are offered, what is withheld, what feedback confirms, what emotion is produced, and what final state counts as resolution.

That is a useful correction to interface metrics that stop at completion rate or satisfaction score. A checkout flow can be clear and still be coercive. A public-benefits form can be efficient and still miscast the applicant as suspicious. A workplace copilot can feel helpful while turning informal judgment into permanent record. The theatrical question is not simply whether the user got through the scene. It is what the scene made the user perform.

This is also where human agency becomes measurable without becoming mystical. A good stage should make refusal, hesitation, correction, and misunderstanding visible parts of the interaction, not failures to be optimized away. If the only successful ending is purchase, disclosure, compliance, or delegation, the scene has already narrowed the user's role before the user acts.

This matters for AI because many failures are action failures, not content failures. A model may summarize correctly while making the wrong social move. It may produce fluent advice while taking the wrong role. It may ask for data in a scene that makes refusal awkward. It may offer certainty because the product script rewards confidence. It may make a user feel heard while leaving no accountable institution behind the response.

In older software, the user often knew the system was a machine. In AI interfaces, the system increasingly speaks as if it were a collaborator, tutor, assistant, therapist, analyst, clerk, advocate, editor, agent, friend, or witness. Laurel's book helps separate the performance of a role from the legitimacy of occupying that role. The design can make a machine feel like a partner before any governance, duty of care, or appeal path exists.

The AI-Agent Reading

Read in 2026, Computers as Theatre looks like a prehistory of agent design. A modern AI agent has a cast: user, model, system prompt, tools, retrieval sources, memories, plugins, administrators, vendors, auditors, and sometimes other agents. It has props: files, calendars, browser tabs, payment forms, tickets, credentials, code repositories, sensors, and databases. It has stage directions: policies, hidden instructions, permission scopes, refusal rules, safety classifiers, and ranking systems.

The danger is that the visible drama can hide the production system. A user sees a friendly assistant. The actual scene may include training data, logs, human review, tool calls, analytics, memory, ranking, escalation rules, and enterprise policy. The frontstage says "I can help." The backstage decides what help means, what gets remembered, what gets reported, what gets optimized, and what kind of person the user becomes inside the workflow.

This is why theatrical analysis is not decorative. It gives governance a way to inspect role design. Is the model performing as a subordinate tool, an expert authority, a confidant, a gatekeeper, or a proxy for an institution? Does the interface make the user feel in control while the decisive action happens elsewhere? Does the system allow exits, pauses, reversals, appeals, and source inspection? Or does it move the user through a carefully lit scene toward consent, dependence, purchase, disclosure, or compliance?

Tool use makes the stage concrete. When an agent can send messages, spend money, change records, retrieve private files, or update code, a line of dialogue becomes a potential institutional act. The interface therefore has to show when the scene has crossed from suggestion into execution, which authority the agent is borrowing, what record is preserved, and how the user or affected person can reverse or contest the action.

A useful agent interface needs an authority ledger, not only a friendly transcript. The ledger should distinguish reading from writing, drafting from sending, simulation from execution, user approval from institutional authorization, and reversible from irreversible action. That connects Laurel's dramatic vocabulary to agent tool permissions and agent logs as receipts: the scene should not end until the user can see what actually happened.

The design rule is threshold clarity. Before an agent crosses from speech to action, the interface should name the tool, credential, data source, affected account, likely consequence, reversibility, and record that will be created. A single glowing "approve" button is not enough when the action can affect someone else's file, money, access, reputation, or legal position.

AI companions make the issue especially sharp. A companion system does not only answer. It casts the user in a relationship. It remembers selected details, mirrors language, manages attention, and can make recurring interaction feel like shared history. Laurel's dramatic lens does not prove that the machine understands the relationship. It shows why the relationship can still become real in the user's life.

Failure Modes of the Stage

The stage metaphor becomes useful when it names concrete failures. Miscasting happens when a system performs as expert, therapist, manager, teacher, advocate, friend, or witness without the duties attached to that role. Prop confusion happens when citations, confidence scores, avatars, typing indicators, badges, or "memory" panels cue trust beyond the evidence they actually provide. Backstage opacity happens when logs, retrieval, ranking, human review, data retention, or tool execution shape the scene without being visible to the person affected.

There are action failures as well. Consent theater turns a complex delegation into a single accept button. Exit erasure makes opt-out, deletion, appeal, or human handoff technically possible but practically buried. False closure lets a fluent answer feel like resolution when the system has only produced a plausible next line. These failures are not solved by better copy alone. They require changes to permissions, defaults, logging, escalation, and institutional responsibility.

Two more failures belong in AI review. Audience substitution happens when an interface appears to serve the user at the keyboard while optimizing for an employer, advertiser, platform, vendor, or agency. Jurisdiction drift happens when a scene feels like advice, companionship, education, or care while the provider treats it legally as entertainment, marketing, support, or experimental software. The stage says one thing; the institutional duty says another.

This matters for the site's recurring concern with recursive reality. A staged role changes how a user acts; the action becomes data; the data trains or configures the next scene; and the next scene appears to confirm that the original role was natural. A copilot that casts a worker as a source of prompts, a tutor that casts a student as a sequence of deficits, or a companion that casts a lonely user as an always-available audience can gradually make that role harder to refuse.

Values and Audience

The second edition's public description emphasizes values-driven design, virtual reality, augmented reality, participatory sensing, public installations, mobile sensors, social networks, online games, and design for emergence. Those additions matter because the stage is no longer just a local screen. It can be a city, a workplace, a classroom, a home, a headset, a feed, a location trace, or a model-mediated institution.

WIRED's profile also stresses one of Laurel's durable concerns: interfaces empower some people and exclude others through their metaphors, assumptions, and required cognitive habits. That point has aged well. The AI interface is full of social assumptions: what counts as professional tone, what counts as safe speech, what counts as a normal body, what counts as relevant context, what counts as a legitimate request, and what counts as evidence.

Designing the stage means deciding who can act fluently on it. A system built around the imagined confident office worker will treat other users as edge cases. A system built around frictionless productivity may make refusal, uncertainty, care, translation, disability access, and community accountability feel like interruptions. A system built around magical assistance may hide the labor and infrastructure that make the performance possible.

Governance and Safety

By June 25, 2026, Laurel's stage metaphor had become a practical governance test. NIST's Generative AI Profile names "Human-AI Configuration" as a risk category, including inappropriate anthropomorphizing, automation bias, over-reliance, and emotional entanglement. That is theatrical language in standards form: the arrangement between human and system can be a risk source, not just the model's internal accuracy.

The EU AI Act points in the same direction. Article 50 requires direct-interaction AI systems to inform natural persons that they are interacting with AI unless that is obvious from context, and requires synthetic outputs to be marked in a machine-readable way where technically feasible. Article 113 sets the general application date at August 2, 2026, while the Commission's June 10, 2026 Code of Practice on Transparency of AI-Generated Content says Article 50 obligations concern marking, detection, and labeling of AI-generated or manipulated content. For interface design, the lesson is concrete: users need to know when they are interacting with a machine, when content is synthetic, and when a system is asking for trust that it has not earned.

The DSA supplies the missing choice-architecture vocabulary for platform contexts. If an online interface makes subscription easy and termination hard, gives one choice more visual weight, repeatedly pressures a user after a choice is made, hides recommender parameters, or buries alternatives to profiling, it is not merely a bad stage. It is the kind of staged decision environment modern platform law has started to name.

The Federal Trade Commission's September 2025 inquiry into AI chatbots acting as companions shows why the scene cannot be treated as harmless polish. The agency asked companies about monetizing engagement, developing characters, testing and monitoring negative impacts, disclosures, age restrictions, and use or sharing of personal information from conversations. Those are not only content questions. They are questions about how a product stages relationship, dependency, privacy, and exit.

Accessibility belongs in the same audit. W3C's WCAG 2.2 recommendation frames accessibility through testable criteria for making content more accessible to people with disabilities. A stage that only some people can perceive, operate, understand, or repair is a stage that distributes agency unequally. For AI interfaces, accessibility also includes source visibility, readable uncertainty, keyboard and assistive-technology paths, understandable consent, and routes to human review.

Agent interfaces add one more governance layer. NIST's AI Agent Standards Initiative treats autonomous action, agent identity, open protocols, and security evaluation as standards work. A theatrical audit should therefore ask not only what the assistant says, but what identity it acts under, what credentials it can use, what tools are backstage, and which action crosses the threshold from performance into execution.

The controls follow from the metaphor. Audit persona, role, memory, tool authority, permission prompts, offstage logging, appeals, data retention, accessibility, and human handoff as one interaction system. Keep synthetic status visible. Keep tool execution distinct from conversation. Make memory inspectable and revocable. Preserve versioned records of prompts, interface states, approvals, and experiments when the system affects rights, money, care, work, education, or public services. Above all, do not let a polished scene turn consent, trust, or compliance into a performance the user cannot later challenge.

A high-stakes AI interface should therefore publish or retain a stage inventory: intended role, prohibited roles, affected audience, data and memory scope, tool permissions, source boundaries, escalation rules, accessibility conformance, evaluation results, incident triggers, and offboarding plan. It should also document who can change the scene after launch: the vendor, deployer, administrator, model provider, safety team, or user. This is not theater criticism as decoration. It is a way of asking whether the product gives people enough reality friction to remain authors of their own actions.

Stage Inventory File

The practical artifact this review takes from Laurel is a stage inventory file. It should sit beside the AI system inventory, model or system card, agent observability record, audit trail, and incident channel. Its purpose is narrower than those documents: it records how the interface scripts the encounter in which people actually disclose, defer, approve, refuse, or delegate.

For every consequential interface, the file should name the cast: user role, system role, institutional owner, vendor, affected third parties, human fallback, and accountability owner. It should name the props: data sources, retrieval stores, uploaded files, memories, credentials, sensors, generated media, citations, scores, confidence displays, and action buttons. It should name the script: defaults, prompts, recommender objectives, escalation paths, refusal behavior, disclosure language, consent points, and the endings the interface treats as success.

The file should also name the backstage machinery. Which model or service is in use? Which policies, tools, analytics, logging systems, human-review queues, retention rules, and A/B tests shape the scene? Which changes can be pushed after launch without user notice? Which parts are configurable by the deployer rather than the vendor? A theatrical audit is weak if it stops at the visible screen, because the apparent scene may be produced by hidden ranking, memory, safety, commercial, or administrative systems.

Finally, it should test the exits. Can a person pause, decline, delete memory, export records, switch to a human, contest a result, revoke tool access, use an accessible path, or leave without penalty? For agents, the inventory should mark the threshold between speech and action: read-only assistance, draft, simulation, external write, purchase, publication, record change, account change, or decision affecting someone else. That threshold belongs with agent tool permissions, agent log receipts, notice and appeal, and the site's humane friction standard.

This makes the stage inventory a safety document rather than a design flourish. It gives reviewers a way to ask whether the interface preserves agency, evidence, and reversibility, or whether it merely makes a managed path feel voluntary. It also makes the site's broader concern concrete: recursive reality is shaped at the point where a designed scene changes what people do, what institutions record, and what future systems then treat as evidence.

Where the Metaphor Needs Friction

The theatrical metaphor can become too elegant if it is detached from political economy. A beautiful stage can still be a high-control interface. Good pacing can still move a user toward extraction. Delight can still be manipulation. Immersion can still be surveillance. Role clarity can still normalize an unjust role.

That is the main limit of reading Computers as Theatre alone. It needs to sit beside books that name power more directly: Atlas of AI, The Costs of Connection, Automating Inequality, Design Justice, and Resisting AI. Laurel gives a vocabulary for experience. Those books ask who owns the theater, who built it, who cleans it, who is watched inside it, who pays, and who can leave.

There is also a risk in treating the user mainly as an actor. In real institutions, people often do not choose the play. A benefits applicant, patient, worker, student, tenant, defendant, or migrant may be forced into the interface because the institution has made it the only door. Agency inside a scripted scene is not the same as power over the script.

Some interfaces should also be less theatrical, not more. A benefits portal, medical triage bot, debt-collection assistant, proctoring tool, or workplace dashboard may need plain procedure, accessible language, source records, appeal rights, and visible limits more than immersion, personality, or dramatic momentum. High-stakes systems should not make deference feel like engagement.

What This Changes

The practical lesson is to audit AI systems as staged relationships, not just as models. A model card can say what a system was trained to do. A theatrical audit asks what role the interface gives the system, what role it gives the user, what props and permissions enter the scene, what happens offstage, how emotion is managed, and what exits remain available.

For a chatbot, that means inspecting persona, memory, escalation, disclaimers, refusal behavior, user dependence, and the handoff to humans. For an enterprise agent, it means inspecting source boundaries, tool authority, audit logs, permission prompts, and whether the agent makes institutional decisions look like conversational suggestions. For a public-service interface, it means asking whether the person can contest the script or only perform compliance inside it.

The audit has four layers: the visible scene, the hidden production system, the real-world action, and the affected audience. A user may be the actor in the interface while another person is the subject of the action: a job applicant scored by a dashboard, a student summarized by a tutor, a patient routed by a triage bot, or a tenant addressed through an agentic landlord system. The stage has to be accountable to everyone it acts upon, not only the person at the keyboard.

Computers as Theatre belongs on the AI shelf because the central problem of contemporary computing is no longer whether machines can display information. It is how machines stage action. The systems now arriving in work, care, education, government, media, and intimacy do not merely answer questions. They assign parts, manage attention, cue trust, conceal machinery, and make some futures easier to perform than others.

Source Discipline

This review separates bibliographic evidence, author biography, interpretive reception, and current governance context. Pearson and ACM establish the book editions and publication metadata. Pearson's front matter, Jenkins, Norman, and WIRED supply historical and design context. NIST, the European Commission, the FTC, and W3C supply current safety, transparency, consumer-protection, and accessibility context; they do not prove that Laurel anticipated every modern AI product. The Pearson sample pages are used only for metadata and table-of-contents context, not for extended quotation.

Claims about a particular interface should identify the product surface, user population, role being staged, data or tool authority involved, time period, and evidence type. A regulator inquiry shows oversight interest, not proven harm. A standards document supplies a risk vocabulary, not product compliance. A transcript shows one interaction path, not population prevalence. A polished demo shows a possible scene, not the backstage machinery that would matter in deployment.

Legal sources are jurisdiction-specific. The DSA applies by platform category and EU scope; the AI Act's Article 50 duties apply on the Article 113 timeline; the Commission's transparency code is voluntary while the underlying Article 50 duties are legal obligations; and the FTC's companion-chatbot work is a 6(b) study, not a court finding. Those distinctions keep stage analysis from turning into a claim that one source solves every interface risk.

The claim here is therefore narrow. Theatrical analysis is not a legal standard, and it is not evidence that an AI system has consciousness, intention, or reciprocal care. It is a disciplined way to inspect role, cue, timing, permission, emotion, evidence, and exit when software begins to act through human situations.

Sources

Book links are paid affiliate links. As an Amazon Associate I earn from qualifying purchases.

Buy on Amazon Browse Books

Return to Blog · Return to Books