# The Prompt Is Still a Punch Card

Ted Johnson

AI Engineer World's Fair 2026

[Talk page](https://ai.engineer/talks/hVJOnuhFmTA-prompt-is-still-punch-card) · [Video](https://www.youtube.com/watch?v=hVJOnuhFmTA)

## The Prompt Is Still a Punch Card

Natural language expanded what computers can understand, but submitting a complete request and waiting still leaves people managing the interaction. Conversational AI needs a different protocol.

### Type, submit, wait, repeat

[0:00](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=0s)

You type a request into a small box and wait. A cursor blinks. A progress indicator cycles through whimsical activities—hullabalooing, tomfoolering, philosophizing—while the system works. Perhaps the answer is useful. Perhaps you rephrase the request and start again. The remarkable thing is how normal this sequence now feels.

![Close-up of a cursor and busy indicator beside a progress bar reading 78%.](https://ai.engineer/api/talk-essay-media/770dbc09ab65a4bcf37d118ff24bb22d749b5ca852fc09a47018a7c0133ee936)

“Please wait…” above a progress bar marked 78%.

Ted Johnson, co-founder of [JoinIn AI](https://joinin.ai/), wants to make that familiarity uncomfortable. After 25 years building enterprise software, collaboration systems and AI interfaces, he experienced ChatGPT as both an extraordinary advance and a disappointment in interaction design. Why should something so capable still require people to learn an unnatural way of communicating?

His framework separates three things that are easily conflated: **channel**, the medium carrying intent; **expression**, the range and richness of meaning an interface permits; and **protocol**, the rules governing the exchange. Improving one does not automatically improve the others. That distinction makes it possible to see what prompting changed—and what it inherited.

### The keyboard feels natural because we learned it

[2:07](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=127s)

The keyboard is familiar, ubiquitous and learned. Typing takes lessons and practice, and attempts to improve it have continued for generations. Dvorak and Colemak rearrange the keys to reduce finger movement. Some enthusiasts give each thumb four, eight or ten keys rather than spending both thumbs on a space bar. Even people who love keyboards recognize that their conventional arrangement is not inevitable.

Johnson shows a historical patent drawing, which he dates to about 1860, followed by the Hansen Writing Ball: a reminder that a radically different physical arrangement was possible. The broader point does not depend on a particular layout winning. We inherited an input device shaped by old constraints, learned to accommodate it, and eventually stopped noticing the accommodation.

A **channel** determines what signals can travel through an interface. A keyboard, microphone, screen, punch card and prompt box each offer different possibilities.

| Channel or representation | What it can carry |
|---|---|
| Text | A sequence of discrete symbols |
| Voice | Words, timing, pitch and hesitation |
| Diagram | Spatial relationships visible together |

These are differences in signal capacity, not guarantees of understanding. A microphone can capture hesitation without a system knowing what that hesitation means. People routinely combine channels; forcing every interaction through one medium discards options we normally use without thinking.

### An ocean of expression inside the same box

[4:20](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=260s)

With language models, the keyboard and Submit button remained in place, but the range of acceptable input expanded dramatically. This is progress in **expression**: how much of what a person means the interface lets through. The physical act of typing is unchanged; what those keystrokes can communicate is not.

Assembly offers opcodes. Shells add commands, inputs and flags. Programming languages provide primitives that can be composed into increasingly sophisticated instructions. Each remains a machine-defined vocabulary within which the user must formulate intent. Natural language opens that vocabulary to ordinary requests. The slide places this progression alongside form fields, ending with open language.

![Five panels labeled Opcodes, Shell, Primitives, Fields, and Open Language show code, form controls, and a natural-language request.](https://ai.engineer/api/talk-essay-media/f1a566e98541435d0c4e002a00257c805ba23ce160f8a08875b150779eda5192)

From Opcodes to Open Language: five forms of computer input.

An ordinary request contains context, nuance and intention that people often do not spell out to one another. Language models make much more of that meaning available to software. Yet, in Johnson’s framing, channels that have persisted for decades—and in some cases much longer—now carry this enormous expressive range through essentially the same narrow interaction. More meaning fits through the box, but the user still has to decide how and when to package it.

### Faster batch is still batch

[6:14](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=374s)

The remaining constraint is **protocol**: the shape of the interaction and the rules participants must follow. Johnson describes the recent LLM advance as an explosion in expression, while prompting retains the structure of punch-card batch processing.

The historical workflow made the separation explicit:

1. Encode the entire request away from the computer.
2. Carry the card deck to an operator and submit the job.
3. Wait for the run to finish.
4. Inspect the printout, find the mistake, repair the deck and resubmit.

The machine engaged with the finished package, not with the person while they were working out what they wanted.

| Stage | Punch-card job | Prompt interaction |
|---|---|---|
| Prepare | Assemble the deck | Compose the request |
| Submit | Deliver the job | Send the message |
| Wait | Await the printout | Await the response |
| Repair | Correct and resubmit | Rephrase and resend |

Updates and summaries improve visibility, and the wait may shrink from hours or overnight to seconds or minutes. But **response speed does not determine when the system is allowed to participate**. If participation begins only after the user submits a complete turn, the central batch constraint remains. A voice interface that transcribes speech into a box and submits it preserves that constraint too; changing the input channel alone does not change the protocol.

### Expertise in assembling the request

[8:04](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=484s)

Prompt engineering often teaches people how to accommodate this protocol: ask for step-by-step thinking, provide examples, request an expert persona—or avoid one. Paste more context, or less. Communicate through Markdown documents. The advice can be useful, but its contradictions also expose how much work goes into preparing a package the machine will accept.

![Overlay lists six suggestions, including thinking step by step, giving examples, asking for expertise, and pasting more or less context.](https://ai.engineer/api/talk-essay-media/4229ec5709f2e1d415794b4157a0fb3af01b817f15207081198fb1e53c6a83e0)

“Packaging a good batch” lists familiar prompting advice.

That skill resembles knowing how to assemble a punch-card deck so the job succeeds. Johnson is not dismissing prompts, punch cards or command lines; each is a powerful response to particular constraints. His question is whether those constraints still justify making users finish packaging their intent before the machine can help.

A system could instead ask a follow-up, clarify a thought as it develops, or acknowledge missing information. Johnson invokes MIT professor [Sherry Turkle’s description of conversation](https://greatergood.berkeley.edu/article/item/how_smartphones_are_killing_conversation): “Conversation is the most human and humanizing thing we do.” Her original context is human relationships; here, the quotation supplies a standard for the richness of interaction that a submit-and-wait loop leaves out.

The [punched-card lineage reaches back to weaving looms](https://www.computerhistory.org/storageengine/punched-cards-control-jacquard-loom/), where a pattern could be set in advance and then run through the machine. Johnson uses that lineage as an analogy for inherited interaction rules. The objection is not that natural language is a poor encoding. It is that the LLM is permitted to engage only after the whole pattern has been prepared.

### The work left outside the model

[10:10](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=610s)

As reasoning, speech, vision, memory and planning improve, the surrounding interface can still leave the human coordinating everything. The user selects relevant context, remembers which question to ask, chooses the moment, notices ambiguity and repairs the output. A capable model behind a prompt box does not automatically take responsibility for any of those tasks.

When the interaction fails, users may conclude that they were insufficiently specific or simply do not understand AI. Johnson locates the problem elsewhere: the interface asks people to operate a new kind of intelligence through an inherited protocol. The race to expose model capabilities has moved faster than the design of the interaction around them.

### Hearing speech is not knowing whom it addresses

[11:09](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=669s)

Johnson’s co-founder tried a simple interaction with an unnamed frontier company’s speech-to-speech voice mode. He asked when the next Timberwolves game would take place, and it answered quickly. He then pretended Johnson had arrived and said, “Hey, Ted, come on in.” The AI responded, “Sure, I'm here. What's on your mind?”

The failure was not answering the sports question. It was treating speech intended for another person as a new message requiring an AI reply. In this example, a one-message/one-reply protocol did not adequately represent the speaker’s intended recipient. Speaker identity, addressee and the obligation to respond are separate pieces of conversational state.

Johnson also points to **[GPT-Realtime-2](https://openai.com/index/advancing-voice-intelligence-with-new-models-in-the-api/)** and reports backchannels such as mm-hmm and right in voice mode. OpenAI dates the API announcement to May 7, 2026, earlier than the late-May release timing he gives; that announcement does not establish the separate Voice trial timing or those particular backchannels. The design direction he highlights is participation during an exchange, rather than merely answering after it.

### Yielding, listening and following the new thread

[12:33](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=753s)

The next clips demonstrate **[NVIDIA PersonaPlex](https://research.nvidia.com/labs/adlr/personaplex/)**, an external research model rather than JoinIn AI’s system. A person says they are thinking about starting a diet. The model begins recommending simple changes, including more vegetables and fruit. Before it finishes, the person interrupts to say they have signed up for a marathon. The model yields, acknowledges the new information and switches to running preparation: regular long runs, hydration, fueling and recovery.

The key behavior is not just cancellation of audio. The model stops, gives up the floor and follows the changed conversational thread. Johnson describes this as real turn-taking: listening and speaking in real time rather than requiring an isolated, completed input before responding.

A second clip is less task-oriented. Someone invites a conversational partner to visit the city, then works through a thought about spray-painted murals and whether people commission them. Short acknowledgments land within the ongoing speech. The listener can signal attention without converting every pause into a full answer or forcing the speaker to surrender the floor.

Conversational flow and group awareness remain different problems. Backchanneling does not by itself establish who is in the room or whether a remark was addressed to the AI. Johnson introduces JoinIn’s work at that boundary: improving the protocol’s representation of human and group conversation.

### A meeting has goals, participants and a floor

[14:10](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=850s)

The JoinIn demonstration opens with greetings involving Sam and Jordan, then a question about the requirement under discussion. The answer identifies expense approvals as the requirement under discussion. Johnson explains the participation mechanism as utility-driven: the system labels statements as questions, proposals or answers, creates goals to fulfill, and takes a turn only when nobody else is speaking or holding the floor. **Silence and an available turn are not necessarily the same thing.**

The group wants users to approve requests faster, but the scope is initially loose. A participant asks what kinds of requests they mean. Expense approvals come first, with access requests later. Then someone tells the AI to hold while the people clarify whether they are designing expense approvals specifically or a general approval workflow. They settle on expense approvals for the first release and access requests as future scope; a participant notes that this distinction changes the data model.

A participant next asks the AI to pull the material up for everyone. This request explicitly addresses the assistant, making the recipient easy to identify. Johnson flags recipient tracking as essential because later requests will not include an explicit AI address. The system must follow both the topic and the relationships among utterances.

### From discussion to a captured requirement

[15:44](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=944s)

The participants work through an approval constraint: expenses over $5,000 need a second approver, involving the manager and finance. A large expense therefore cannot be handled as a single tap; below the limit, they accept one-tap approval. The group explicitly agrees on expense approvals with a $5,000 threshold. Johnson identifies this as the moment the AI resolves its scope objective without anyone composing a dedicated prompt or pressing Submit.

Only afterward does someone explicitly ask the AI to capture the decision. Its spoken summary includes expense approvals for the first release, excludes access requests, and lets managers approve or reject an expense directly from a notification. It attributes routing above $5,000 to the finance controls policy. A compact representation of that captured content is:

```json
{
  "firstRelease": ["expense approvals"],
  "outOfScope": ["access requests"],
  "notificationActions": ["approve", "reject"],
  "secondApproverAboveUSD": 5000
}
```

The distinction is between following the discussion to resolve an objective and responding to a later request to capture it. Those are separate conversational events.

A participant then asks to make the threshold 10,000 instead of 5,000, without explicitly addressing the AI. The assistant recognizes a possible revision and asks whether it should update the requirement to that threshold. The participant confirms. This establishes a confirmed change request; the clip does not establish authorization to override the finance policy or show a persisted requirement update.

A confirmed revision is not a demonstrated write
The assistant infers the intended revision and seeks confirmation; the demonstrated outcome is a confirmed request.
Constructed example: Object IDs, state labels and the JSON field secondApproverAboveUSD are teaching representations, not disclosed implementation fields. Scope, threshold values and confirmation come from the demo; the requirement identifier is withheld in the corrected public source.
Participant revision — unchanged: Actually, make the threshold 10,000, not 5,000.
Operation: Recognize the revision, ask whether to update the requirement, and receive the participant's confirmation.
- First release
  - Before: Captured requirement: Expense approvals; access requests out of scope
  - After: After verbal confirmation: Expense approvals; access requests out of scope
- Last captured second-approver rule
  - Before: Captured requirement: Expenses over $5,000
  - After: After verbal confirmation: Expenses over $5,000; persisted revision not shown
- Confirmed change request
  - Before: Captured requirement: Not present
  - After: After verbal confirmation: Set secondApproverAboveUSD to 10000; participant confirmed
The assistant infers the intended revision and seeks confirmation; the demonstrated outcome is a confirmed request.

The conversation then changes topics. Someone asks whether the room is free after the meeting. The AI begins answering, is interrupted by a clarification asking whether it is available until 3:00, and confirms that it is. The assistant handles a side question and an interruption without requiring the meeting to be repackaged as a new, carefully constructed task.

### Which burdens can the interface take over?

[17:19](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=1039s)

These examples suggest a broader role for AI: **intelligence is also an interface technology**. Better models behind prompts, agents and loops are only part of the opportunity. Reasoning, listening and inference can help remove the constraints that previously required people to adapt to a machine’s syntax, forms and timing.

The design question becomes: what are humans still doing only because machines used to be unable to do it? The answer need not be another chat window, voice mode or wall of Markdown. It may be a question, a pause, a sketch, a checklist, a quiet aside or no response at all. An intelligent interface can choose an appropriate channel and moment instead of making the user manage both.

Johnson expects removing these burdens to reduce friction and support adoption. Earlier interfaces—punch cards, typed commands, menus, phone gestures and prompts—each improved how people encode intent, while carrying some constraints into the next era. He describes the resulting work as translation, precision, context and repair taxes.

Putting those taxes down does not require making every interaction voice-based, promising magic or replacing human judgment. It requires computers to become more fluent with people. The deeper design challenge is not simply teaching users how to adopt AI: it is deciding how greater machine understanding should change the interface, so that people no longer have to reshape every thought before a machine can participate.

## Resources

- [NVIDIA PersonaPlex](https://research.nvidia.com/labs/adlr/personaplex/) — Research overview with interruption and backchannel examples, architecture, training details and evaluation context.
- [PersonaPlex code and setup](https://github.com/NVIDIA/personaplex) — Instructions for running the full-duplex speech model locally and evaluating recorded audio; model access requires license acceptance.
- [PersonaPlex research paper](https://arxiv.org/abs/2602.06053) — Research on combining role prompts and voice conditioning with full-duplex conversation.
- [GPT-Realtime-2 announcement](https://openai.com/index/advancing-voice-intelligence-with-new-models-in-the-api/) — OpenAI's dated API launch announcement explains realtime reasoning, interruption handling and tool use.
- [JoinIn.ai Pulse](https://joinin.ai/) — Current meeting-assistant product with objective tracking, contextual answers and a desktop beta.
- [Sherry Turkle on reclaiming conversation](https://greatergood.berkeley.edu/article/item/how_smartphones_are_killing_conversation) — An interview about conversation, empathy and the effects of phones on human relationships.
- [The Jacquard loom and punched-card history](https://www.computerhistory.org/storageengine/punched-cards-control-jacquard-loom/) — Museum history tracing punched-card control from weaving to computing and census tabulation.

## Slides

### The Prompt Is Still a Punch Card

The talk opens with a familiar ritual: typing a request into a small box and waiting.

[0:01](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=1s) [Title slide: The Prompt Is Still a Punch Card. Make the familiar strange, then earn the room.](https://assets.ai.engineer/sites/aiecode2025/sha256/7fbe4d21cafa5bcdeac3d403be218a131398b86f7930e16cce10c835ea5f1f80.webp)

The Prompt Is Still a Punch Card

Make the familiar strange,
then earn the room

joinin.ai

### Waiting at the Cursor

A pointer sits beside a loading indicator as Ted Johnson describes typing a request, waiting for a response, and sometimes rephrasing it to try again.

[0:14](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=14s) [Close-up of a screen showing a pointer beside a loading indicator.](https://assets.ai.engineer/sites/aiecode2025/sha256/f2a2b6f1f4be760c3af1c271578fa4621136b7df432781956eb549234e652ab0.webp)

### Five Interface Channels

Five panels contrast cursor, waveform, diagram, form, and sketch interfaces. The speaker argues that AI still uses a typed box, but it can now carry rich human language.

[4:01](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=241s) [Five panels illustrate cursor, waveform, diagram, form, and sketch inputs.](https://assets.ai.engineer/sites/aiecode2025/sha256/c669bb54e7942160ebd0db1992361500202f13eb457c2ad2d3838f51738b862f.webp)

Cursor
Type here

Waveform

Diagram

Form
Name
Enter name
Email
Enter email
Role
Select role
Submit

Sketch
Dashboard

### From Opcodes to Open Language

The slide traces expression from opcodes and shell commands through programming primitives and form fields to an open-language request. The speaker says natural language opens up the fixed vocabulary of earlier interfaces.

[5:00](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=300s) [Five panels compare opcodes, shell commands, programming primitives, form fields, and open language.](https://assets.ai.engineer/sites/aiecode2025/sha256/f1992d1323c8a9a52a3f61d28e0c436ff35827d97623f4250b800699c9be0dd1.webp)

; bytes
0000  55 48 89 E5 48 83
0008  EC 20 48 8B 7D F8
0010  48 8B 75 F0 5D C3
0018  90 90 90 90 90 90

; x86-64
0000  push  rbp
0001  mov   rbp, rsp
0004  sub   rsp, 0x20
0008  mov   rdi, [rbp-0x8]
000c  mov   rsi, [rbp-0x10]
0010  pop   rbp
0011  ret

0x01
Opcodes

$ # Find Python files > 1KB
$ find . -type f -name "*.py" -size +1k

$ # Count TODOs in those files
$ grep -RIn "TODO" . | wc -l
42

$ # Show top 5 by size
$ ls -lh $(find . -name "*.py") \
    | sort -k5 -hr | head -n 5
-rw-r--r--  22K  app/main.py
-rw-r--r--  18K  lib/parser.py
-rw-r--r--  12K  api/client.py
-rw-r--r--  8.0K  utils/io.py
-rw-r--r--  6.1K  tests/test_api.py

$ # Fetch API and pretty-print
$ curl -s https://api.example.com/\
    users?limit=3 | jq .
[
  { "id": 1, "name": "Ada" },
  { "id": 2, "name": "Linus" },
  { "id": 3, "name": "Grace" }
]
$
Shell

# Variables
limit = 100
items = []

# Functions
def fetch(url, timeout=5):
    resp = http.get(url, timeout=timeout)
    return resp.json()

# Conditionals
if resp.status_code == 200:
    data = resp.json()
else:
    raise Error(resp.text)

# Loops
for item in data:
    if item["active"]:
        items.append(item)

# API Call (primitive)
resp = http.get("/users", params={"limit": limit})

# Data (JSON) Primitive
user = {
  "id": 123,
  "email": "ada@example.com",
  "role": "admin"
}
Primitives

Endpoint
https://api.example.com/v1/users
Method
GET
Auth
Bearer Token
Token
••••••••••••••••
Query Parameters (JSON)
{
  "limit": 100,
  "active": true,
  "role": "admin"
}
Timeout (s)
10
Response Format
JSON
Fields

What would you like to build?

Write a Python function that parses a CSV file, deduplicates rows by email (case-insensitive), keeps the most recent record by updated_at, and returns the result as a JSON array.

Requirements:
• Use csv.DictReader
• Stream large files
• Validate emails
• Sort by updated_at desc
• Include a count summary
• Add type hints and docstring

Open Language

### A Straw Into the Ocean

A prompt reaches into an ocean through a straw. The speaker describes that ocean as the context, nuance, and intent in an ordinary human request.

[5:41](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=341s) [A prompt box connects by a straw to an ocean, with glowing interface icons above the water.](https://assets.ai.engineer/sites/aiecode2025/sha256/b60d480c61cdbe96fe832682f7d684d793a0149730192ae855a56257de11982a.webp)

PROMPT
Tell me what matters.

JUST A STRAW INTO THE OCEAN.

### Black Box, Big Possibilities

A prompt feeds into an opaque AI box. The speaker questions whether users still need to package their intent in advance when AI can ask follow-up questions and clarify.

[8:44](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=524s) [A prompt box connects to a dark cube labeled AI above the caption Black Box. Big Possibilities.](https://assets.ai.engineer/sites/aiecode2025/sha256/6bc7a8902943c1409dec52ee66c3b2dbb44d3c77e9f58c8990b39639fafe4e5a.webp)

PROMPT
Explain it like I’m five.

AI

BLACK BOX. BIG POSSIBILITIES.

### Batch Carried Forward

The slide traces a batch workflow from loom to prompt: package input, submit it, wait for processing, and receive a result. The speaker argues that AI still waits for a complete turn before engaging.

[9:35](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=575s) [A progression from loom to punch card, terminal, and prompt, connected by a shared batch workflow.](https://assets.ai.engineer/sites/aiecode2025/sha256/21555b274d2a9d4e68ff5a57b209f6bb3a2fd5deae431d3dd61a3e4032f3fb06.webp)

Batch Carried Forward
Loom → Punch Card → Terminal → Prompt

1 LOOM
› encode pattern, run batch

2 PUNCH CARD
[illegible punch card text]
› encode program, submit batch

3 TERMINAL
$ JOB PAYROAL
$ QUEUE B
$ SUBMIT
Job 31245 submitted
$
› enter command, wait

4 PROMPT
New Chat
Analyze Q2 sales by region and summarize top drivers.
› package intent, submit

ENCODE / PACKAGE → SUBMIT → WAIT / PROCESS → OUTPUT / RESULT

New intelligence, old protocol.

### Reported bidirectional voice model

The slide reports that early tests of OpenAI’s unannounced GPT-Bidi-1 show simultaneous speaking and listening with natural interruptions, and that rollout has begun for a select group of app users.

[12:05](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=725s) [A summary of reported testing, interruption handling, and limited rollout of an unannounced voice model.](https://assets.ai.engineer/sites/aiecode2025/sha256/7d8d347b6c254ec840be5f8be7b10f415732540f738f42c2fab51d355b329f6b.webp)

TL;DR

▪ OpenAI is reportedly testing an unannounced bidirectional voice model called “GPT-Bidi-1.”
▪ Code references and early user tests show that the model can speak, hear, and listen simultaneously, handling mid-sentence interruptions naturally.
▪ The unannounced model has already started rolling out to a select group of app users, hinting at an official release window this week.

### NVIDIA PersonaPlex

In a PersonaPlex demo, the user interrupts diet advice to mention a marathon. The model switches to advice on training for the race.

[12:32](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=752s) [The NVIDIA PersonaPlex project page shows its title, publication date, authors, and links to research materials.](https://assets.ai.engineer/sites/aiecode2025/sha256/1e5ec74fd3f025009cd85a3110eaa5a45b9352d2f39f0692989c317eeb429927.webp)

NVIDIA PersonaPlex: Natural Conversational AI With Any Role and Voice

Published: January 15, 2026

Read the paper
Model Weights
Code

Authors
Rajarshi Roy, Jonathan Raiman, Sang-gil Lee, Teodor-Dumitru Ene, Robert Kirby, Sungwon Kim, Jaehyeon Kim, Bryan Catanzaro.

NVIDIA PersonaPlex
User

Interface text:
NVIDIA ADLR
Projects
NVIDIA
AI
NVIDIA ADLR

### PersonaPlex assistant example

In NVIDIA’s PersonaPlex demo, the user interrupts diet advice to mention a marathon. The model yields and responds with running advice.

[12:42](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=762s) [The PersonaPlex examples page shows an assistant audio player and describes an interruption evaluation.](https://assets.ai.engineer/sites/aiecode2025/sha256/7f6e5faee92dbce040fa46e5e6e433cb63f9c3f7fbb8d76d61534c2b5b2594d4.webp)

Enriching PersonaPlex’s output with non-verbal aspects creates an important qualitative difference relative to systems without this dimension: PersonaPlex now recreates some of the same cues humans use to read intent, emotions, or comprehension.

Examples

The following examples showcase PersonaPlex’s behavior across different scenarios. In all audio files, you can hear the user speaking in the left channel and PersonaPlex in the right channel (shown in green).

1 Assistant
0:26 / 0:26

Prompt: You are a wise and friendly teacher. Answer questions or provide advice in a clear and engaging way.

In this example from FullDuplexBench's interruption evaluation, PersonaPlex demonstrates general knowledge, interrupterability, and natural turn taking.

2 Customer Service - Banking
0:00 / 0:55

Prompt: You work for First Neuron Bank which is a bank and your name is Sanni Virtanen.
Information: The customer's transaction for $1,200 at Home Depot was declined. Verify customer identity. The transaction was flagged due to an unusual location (transaction attempted in Miami, FL; customer normally transacts in Seattle, WA).

Interface text:
NVIDIA
AI
NVIDIA ADLR

### PersonaPlex natural backchanneling

In the audio demo, PersonaPlex responds with short phrases such as “Oh, okay” and “Yeah” while the other speaker continues. The page also shows a separate space emergency scenario.

[13:20](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=800s) [The PersonaPlex examples page shows audio players for natural backchanneling and a space emergency scenario.](https://assets.ai.engineer/sites/aiecode2025/sha256/7407bc749693f2566ed72afe910d38318af79e5c7eae3d9831bedfacc3cd37bb.webp)

NVIDIA
AI
NVIDIA ADLR

information for new patients. Information: Record full name, date of birth, any medication allergies, tobacco smoking history, alcohol consumption history, and any prior medical conditions. Assure the patient that this information will be confidential, if they ask.

PersonaPlex demonstrates instruction following from text prompt, and registration of important user details from user speech.

4 Natural Backchanneling
0:00 / 0:16

Prompt: You enjoy having a good conversation.

In this example from FullDuplexBench's backchanneling evaluation, PersonaPlex produces a variety of conversational backchannels like "oh okay", "okay", "yeah", "yeah, I think they do" that signal active listening without interrupting the speaker's flow. The backchannels are contextual in content and tone.

5 Space Emergency Scenario
0:00 / 3:19

Prompt: You enjoy having a good conversation. Have a technical discussion about fixing a reactor core on a spaceship to Mars. You are an astronaut on a Mars mission. Your name is Alex. You are already dealing with a reactor core meltdown on a Mars mission. Several ship systems are failing, and continued instability will lead to catastrophic failure. You explain what is happening and you urgently ask for help thinking through how to stabilize the reactor.

PersonaPlex demonstrates strong generalization to text prompts well outside its training distribution (assistant, customer service, open-ended casual conversations). It maintains a persona coherent with the text prompt throughout the extended

### Conversation is more than turn-taking

The diagram connects participant awareness, conversational flow, meaning and action. The speaker highlights knowing who is addressed as a challenge beyond making listening noises.

[13:43](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=823s) [Diagram of participants, conversational flow, meaning and action surrounding natural conversation.](https://assets.ai.engineer/sites/aiecode2025/sha256/21f91a494e61d48bb136174b6c657dcd9bc81d00ca365dda90a5ac4e5de4bc59.webp)

Conversation is more than turn-taking
What real-time conversational AI has to understand

1. PARTICIPANTS
Who is here
Who is speaking
Who is listening
Who is being addressed

2. FLOW
Turn-taking
Backchannels
mm-hmm
Interruptions & repair
Timing
Overlap

Natural conversation =
timing + context +
repair + social understanding

3. MEANING
Attention
Thread tracking
Grounding
Shared context
Beliefs / intentions

4. ACTION
Decisions / commitments
When to speak vs wait

### Noticing scope ambiguity

After Dana puts expense approvals first and access requests eventually, the demo AI flags a possible ambiguity between expense approvals and a general approval workflow.

[15:02](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=902s) [Meeting demo shows an AI identifying ambiguity about approval scope.](https://assets.ai.engineer/sites/aiecode2025/sha256/dc35f2d6ea14670cd5c603ed08e45d05ffa8a8b406054721aa042406be00bdcd.webp)

Product requirements review · live

Dana — Stakeholder
SPEAKING
Sam — Product · Lead
Jordan — Engineering

Sam
Good afternoon, everyone.

Dana
Afternoon, Sam. Hi Jordan.

Jordan
Good afternoon — good to see you both.

Dana — question
Quick one — which requirement is this? Do we have an ID?

AI — answer
This is REQ-142 — expense approvals.

Dana — proposal
Right. We need users to approve requests faster.

Sam — agree
Yeah — the approval flow's too slow.

Jordan — question
What kind of requests, though?

Dana — answer
Expense approvals first. Access requests eventually.

AI
Noticing
something looks ambiguous

Internal signal
Possible scope ambiguity: expense approvals vs. a general approval workflow.

GOALS
Q: Which requirement is this?
REQ-142 — expense approvals

Interface text:
Pause
Replay

### Choosing when to speak

The AI flags a possible scope ambiguity privately and suggests a clarification. After Sam says “AI, hold that,” it remains silent while he begins to ask the question himself.

[15:05](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=905s) [Meeting demo shows the AI listening and suggesting a clarification to the lead.](https://assets.ai.engineer/sites/aiecode2025/sha256/bd4ff2e155da1996fccdf4b9c6aa1c353fe66302cad4f43d99993d850d8f575d.webp)

Sam
Good afternoon, everyone.

Dana
Afternoon, Sam. Hi Jordan.

Jordan
Good afternoon — good to see you both.

Dana · → question
Quick one — which requirement is this? Do we have an ID?

AI · ← answer
This is REQ-142 — expense approvals.

Dana · → proposal
Right. We need users to approve requests faster.

Sam · ← agree
Yeah — the approval flow's too slow.

Jordan · → question
What kind of requests, though?

Dana · ← answer
Expense approvals first. Access requests eventually.

Sam · → directive
AI, hold that.

Sam · → question
Actually — let's pause. Expense approvals, or a general approval wor[illegible]

AI
Listening
choosing not to speak

Private to lead
Possible scope ambiguity: expense approvals vs. a general approval workflow.

Suggested clarification
Worth clarifying: are we building expense approvals, or a general approval workflow?
Hold
Bring into room

GOALS
Q: Which requirement is this?
REQ-142 — expense approvals
Resolve approval scope

Intelligence is knowing when not to speak.

Interface text:
Product requirements review · live
Pause
Replay
Dana
Stakeholder
Sam
Product · Lead
SPEAKING
Jordan
Engineering

### Product requirements review

The team settles on expense approvals for the first release. The AI holds a suggested clarification, then privately recalls a policy requiring second-level sign-off for expenses over $5,000.

[15:20](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=920s) [Meeting demo shows participants settling the initial scope while the AI listens and indicates a likely next speaker.](https://assets.ai.engineer/sites/aiecode2025/sha256/a0e2aaff4d2e9803a991fc4f28770917d059d3374339042ba68a47c0a5307f71.webp)

Product requirements review

Dana — Stakeholder
Sam — Product · Lead — SPEAKING
Jordan — Engineering — LIKELY NEXT

Jordan
Good afternoon — good to see you both.

Dana — question
Quick one — which requirement is this? Do we have an ID?

AI — answer
This is REQ-142 — expense approvals.

Dana — proposal
Right. We need users to approve requests faster.

Sam — agree
Yeah — the approval flow's too slow.

Jordan — question
What kind of requests, though?

Dana — answer
Expense approvals first. Access requests eventually.

Sam — directive
AI, hold that.

Sam — question
Actually — let's pause. Expense approvals, or a general approval workflow?

Dana — answer
Expense approvals. First release.

Sam
Access requests are future scope.

AI
Listening
choosing not to speak

Private to lead
Possible scope ambiguity: expense approvals vs. a general approval workflow.

Suggested clarification
Worth clarifying: are we building expense approvals, or a general approval workflow?
Hold
Bring into room

GOALS
Q: Which requirement is this?
REQ-142 — expense approvals
Resolve approval scope

Intelligence is knowing when not to speak.

Interface text:
live
Pause
Replay

[15:29](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=929s) [Meeting interface recalls an approval policy while participants clarify the first release.](https://assets.ai.engineer/sites/aiecode2025/sha256/1ae96f4e384e25b8d85d3546c8ee9cdac6da57dc83c98136f252619b85ff2b79.webp)

Product requirements review

Dana — Stakeholder
Sam — Product · Lead — SPEAKING
Jordan — Engineering

AI — answer
This is REQ-142 — expense approvals.

Dana — proposal
Right. We need users to approve requests faster.

Sam — agree
Yeah — the approval flow's too slow.

Jordan — question
What kind of requests, though?

Dana — answer
Expense approvals first. Access requests eventually.

Sam — directive
AI, hold that.

Sam — question
Actually — let's pause. Expense approvals, or a general approval workflow?

Dana — answer
Expense approvals. First release.

Sam — proposal
Access requests are future scope.

Jordan — acknowledge
That changes the data model. Good to know.

Sam
AI, pull that up for everyone.

AI
Recalling context
from the project's own knowledge

Private to lead
From the project charter — Finance Controls Policy v3 already requires second-level sign-off for expenses over $5,000. No one's mentioned it.

Suggested clarification
Worth clarifying: are we building expense approvals, or a general approval workflow?
Hold
Bring into room

GOALS
Q: Which requirement is this?
REQ-142 — expense approvals
Resolve approval scope

It also remembers what the room forgot.

Interface text:
live
Pause
Replay

### Sharing the policy

After Sam asks, the AI shares the policy. The team agrees that expenses over $5,000 need a manager and Finance approver, while under five can use one tap.

[15:42](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=942s) [The AI shares an approval policy above the meeting conversation.](https://assets.ai.engineer/sites/aiecode2025/sha256/1978211da0dc1057cb307dcca1cda9afb561e0193ed2fdd818e2c32a590db4a2.webp)

Dana
Stakeholder

Sam
Product · Lead

Jordan
Engineering
SPEAKING

SHARED BY AI
Retrieved from project knowledge
Finance Controls Policy v3
§4.2 · Approval thresholds
Expense approvals exceeding $5,000 require second-level authorization — the reporting manager and a Finance approver.

Jordan — acknowledge
That changes the data model. Good to know.

Sam — directive
AI, pull that up for everyone.

Jordan — acknowledge
Oh — I'd forgotten that was a rule.

Dana — question
So over five thousand needs a second approver?

Sam — answer
Yep — manager plus Finance.

Jordan — proposal
So a big one can't be a single tap.

Sam — agree
Right — over the limit it routes to a second approver.

Dana — agree
Agreed. Under five, one tap's fine.

Jordan
Works for me.

AI
Presenting
sharing the source with the room

Suggested clarification
Worth clarifying: are we building expense approvals, or a general approval workflow?
Hold
Bring into room

GOALS
Q: Which requirement is this?
REQ-142 — expense approvals
Resolve approval scope

Pulling up the source — so the room sees it too.

Interface text:
Product requirements review · live
Pause
Replay

### Replying in chat

The demo keeps the approval policy visible to the room while the AI answers Sam’s separate question in chat: the current median is 2.3 days, with a same-day target.

[16:09](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=969s) [The shared policy remains visible while the AI answers a side question in chat.](https://assets.ai.engineer/sites/aiecode2025/sha256/9405194b97ca9d3f5075d7bc19ec9897e5445f5ab3b49b0498fa36be94524bc8.webp)

Dana
Stakeholder

Sam
Product · Lead
SPEAKING

Jordan
Engineering

SHARED BY AI
Retrieved from project knowledge
Finance Controls Policy v3
§4.2 · Approval thresholds
Expense approvals exceeding $5,000 require second-level authorization — the reporting manager and a Finance approver.

Sam — directive
AI, pull that up for everyone.

Jordan — acknowledge
Oh — I'd forgotten that was a rule.

Dana — question
So over five thousand needs a second approver?

Sam — answer
Yep — manager plus Finance.

Jordan — proposal
So a big one can't be a single tap.

Sam — agree
Right — over the limit it routes to a second approver.

Dana — agree
Agreed. Under five, one tap's fine.

Jordan — agree
Works for me.

Sam
Okay — agreed. Expense approvals, five-thousand threshold.

AI
Replying in chat
a quiet side question

Suggested clarification
Worth clarifying: are we building expense approvals, or a general approval workflow?
Hold
Bring into room

CHAT
SAM
what's our current median approval time?

AI
2.3 days median right now; the target is same-day.

SAM
right, that's fine

GOALS
Q: Which requirement is this?
REQ-142 — expense approvals
Resolve approval scope

Pulling up the source — so the room sees it too.

Interface text:
Product requirements review · live
Pause
Replay

### Product requirements review

In the demo, the AI captures and speaks the agreed scope: expense approvals for the first release, with a second approver for amounts over $5,000. Access requests are out of scope.

[16:15](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=975s) [The meeting interface records the agreed expense approval scope and threshold as a requirement.](https://assets.ai.engineer/sites/aiecode2025/sha256/58645856f10bf099d09aa38a3eee30262110146d8d32f78e0ffbfc4a85bc8aa4.webp)

Capturing decision
turning talk into a spec

Clarification resolved
Brought into the room → resolved.

Expense approvals. First release.

Sam — proposal
Access requests are future scope.

Jordan — acknowledge
That changes the data model. Good to know.

Sam — directive
AI, pull that up for everyone.

Jordan — acknowledge
Oh — I'd forgotten that was a rule.

Dana — question
So over five thousand needs a second approver?

Sam — answer
Yep — manager plus Finance.

Jordan — proposal
So a big one can't be a single tap.

Sam — agree
Right — over the limit it routes to a second approver.

Dana — agree
Agreed. Under five, one tap's fine.

Jordan — agree
Works for me.

Sam
Okay — agreed. Expense approvals, five-thousand threshold.

CHAT
SAM
what's our current median approval time?
AI
2.3 days median right now; the target is same-day.
SAM
right, that's fine

GOALS
Q: Which requirement is this?
REQ-142 — expense approvals
Resolve approval scope
Expense approvals — first release
Apply $5,000 second-level threshold
Access requests — future scope

REQUIREMENT
Expense approvals only for the first release. Over $5,000 requires second-level sign-off (Finance Controls Policy v3). Access requests are out of scope.

A decision — not a transcript.

Interface text:
Product requirements review · live
Pause
Replay
Dana — Stakeholder
Sam — Product · Lead
SPEAKING
Jordan — Engineering
AI

[16:32](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=992s) [A meeting interface shows the AI speaking a summary of the expense approval decision.](https://assets.ai.engineer/sites/aiecode2025/sha256/58322449c8f624229b80b0243caf05892e0b3cda7fca4848ed30a91519d92e15.webp)

Speaking
invited into the room

First release supports expense approvals only — access requests are out of scope. Managers can approve or reject an expense right from a notification. And per the Finance Controls Policy, anything over five thousand dollars routes to a second approver.

Clarification resolved
Brought into the room → resolved.

Access requests are future scope.

Jordan — acknowledge
That changes the data model. Good to know.

Sam — directive
AI, pull that up for everyone.

Jordan — acknowledge
Oh — I'd forgotten that was a rule.

Dana — question
So over five thousand needs a second approver?

Sam — answer
Yep — manager plus Finance.

Jordan — proposal
So a big one can't be a single tap.

Sam — agree
Right — over the limit it routes to a second approver.

Dana — agree
Agreed. Under five, one tap's fine.

Jordan — agree
Works for me.

Sam — closing
Okay — agreed. Expense approvals, five-thousand threshold.

Sam
AI, capture that for us.

CHAT
SAM
what's our current median approval time?
AI
2.3 days median right now; the target is same-day.
SAM
right, that's fine

GOALS
Q: Which requirement is this?
REQ-142 — expense approvals
Resolve approval scope
Expense approvals — first release
Apply $5,000 second-level threshold
Access requests — future scope

REQUIREMENT
Expense approvals only for the first release. Over $5,000 requires second-level sign-off (Finance Controls Policy v3). Access requests are out of scope.

A decision — not a transcript.

Interface text:
Product requirements review · live
Pause
Replay
Dana — Stakeholder
Sam — Product · Lead
Jordan — Engineering

### Generated requirement

The demo turns the expense approval discussion into a requirement with acceptance criteria. Expenses over $5,000 need a second approver; Product is to confirm the threshold with Finance by Friday.

[16:50](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=1010s) [The meeting interface displays a detailed expense approval requirement and an open question about the threshold.](https://assets.ai.engineer/sites/aiecode2025/sha256/a154c83e57768d19c908613bcde6af21dae304fc0dce354a91b0d0371fb4e1a2.webp)

Access requests are future scope.

Jordan — acknowledge
That changes the data model. Good to know.

Sam — directive
AI, pull that up for everyone.

Jordan — acknowledge
Oh — I'd forgotten that was a rule.

Dana — question
So over five thousand needs a second approver?

Sam — answer
Yep — manager plus Finance.

Jordan — proposal
So a big one can't be a single tap.

Sam — agree
Right — over the limit it routes to a second approver.

Dana — agree
Agreed. Under five, one tap's fine.

Jordan — agree
Works for me.

Sam — closing
Okay — agreed. Expense approvals, five-thousand threshold.

Sam
AI, capture that for us.

AI
2.3 days median right now; the target is same-day.

SAM
right, that's fine

GOALS
Q: Which requirement is this?
REQ-142 — expense approvals
Resolve approval scope
Expense approvals — first release
Apply $5,000 second-level threshold
Access requests — future scope
Q: Is the $5,000 threshold still current?

REQUIREMENT
Expense approvals only for the first release. Over $5,000 requires second-level sign-off (Finance Controls Policy v3). Access requests are out of scope.

REQUIREMENT
Managers can approve or reject expense requests from a notification.

ACCEPTANCE CRITERIA
• Manager receives a notification for a pending expense.
• Manager can approve or reject from the notification.
• Expenses over $5,000 route to second-level approval (manager + Finance).
• The employee is notified of the decision.
• The decision is recorded in audit history.

OUT OF SCOPE
• Access-request approvals.
• General approval-workflow builder.

OPEN QUESTION
Is the $5,000 second-level threshold still current? (Finance Controls Policy v3, §4.2)

OWNER
Product to confirm the threshold with Finance by Friday.

From conversation to code.

Interface text:
Product requirements review · live
Pause
Replay
Dana — Stakeholder
Sam — Product · Lead
Jordan — Engineering

### Requirement becomes a work item

The demo turns the expense approval discussion into REQ-142 with a $5,000 second-approval threshold. Dana then proposes raising it to $10,000, while the displayed work item still retains the original threshold.

[16:54](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=1014s) [A work item lists expense approval criteria while a participant proposes a higher threshold.](https://assets.ai.engineer/sites/aiecode2025/sha256/1c133fec67faa9f028453bf12fdfd72e7a281f4b53e8a02c976af55505db7ada.webp)

That changes the data model. Good to know.

Sam — directive
AI, pull that up for everyone.

Jordan — acknowledge
Oh — I'd forgotten that was a rule.

Dana — question
So over five thousand needs a second approver?

Sam — answer
Yep — manager plus Finance.

Jordan — proposal
So a big one can't be a single tap.

Sam — agree
Right — over the limit it routes to a second approver.

Dana — agree
Agreed. Under five, one tap's fine.

Jordan — agree
Works for me.

Sam — closing
Okay — agreed. Expense approvals, five-thousand threshold.

Sam — directive
AI, capture that for us.

Dana
Actually — make the threshold ten thousand, not five.

CHAT
SAM
what's our current median approval time?

AI
2.3 days median right now; the target is same-day.

SAM
right, that's fine

GOALS
Q: Which requirement is this?
REQ-142 — expense approvals
Resolve approval scope
Expense approvals — first release
Apply $5,000 second-level threshold
Access requests — future scope
Q: Is the $5,000 threshold still current?

REQ-142 — TO DO
Approve / reject expense requests from a notification

First release: managers can approve or reject pending expense requests directly from a notification. Expenses over $5,000 route to second-level approval per Finance Controls Policy v3 §4.2. Decision is written to audit history. Access requests are explicitly out of scope.

ACCEPTANCE CRITERIA
□ Manager receives a notification for a pending expense
□ Manager can approve or reject from the notification
□ Expenses over $5,000 require second-level approval (manager + Finance)
□ Employee is notified of the decision
□ Decision is recorded in audit history

expense-approvals · first-release · compliance · 5 pts

From conversation to code.

Interface text:
Product requirements review · live
Pause · Replay
Dana — Stakeholder — SPEAKING
Sam — Product · Lead
Jordan — Engineering

### AI asks to update the requirement

Dana proposes raising the approval threshold from $5,000 to $10,000. The AI asks for confirmation while the work item still shows the original threshold.

[17:01](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=1021s) [The AI asks whether to update the threshold while the work item still shows the original amount.](https://assets.ai.engineer/sites/aiecode2025/sha256/a457634459d7880760ed3b69e972621d553f309fb460c841d4c47f7c8d117772.webp)

Dana — Stakeholder
Sam — Product · Lead
Jordan — Engineering

Jordan — acknowledge
Oh — I'd forgotten that was a rule.

Dana — question
So over five thousand needs a second approver?

Sam — answer
Yep — manager plus Finance.

Jordan — proposal
So a big one can't be a single tap.

Sam — agree
Right — over the limit it routes to a second approver.

Dana — agree
Agreed. Under five, one tap's fine.

Jordan — agree
Works for me.

Sam — closing
Okay — agreed. Expense approvals, five-thousand threshold.

Sam — directive
AI, capture that for us.

Dana — proposal
Actually — make the threshold ten thousand, not five.

AI
Want me to update the requirement to a ten-thousand threshold?

CHAT
SAM: what's our current median approval time?
AI: 2.3 days median right now; the target is same-day.
SAM: right, that's fine

GOALS
Q: Which requirement is this?
REQ-142 — expense approvals
Resolve approval scope
Expense approvals — first release
Apply $5,000 second-level threshold
Access requests — future scope
Q: Is the $5,000 threshold still current?

REQ-142 — TO DO
Approve / reject expense requests from a notification

First release: managers can approve or reject pending expense requests directly from a notification. Expenses over $5,000 route to second-level approval per Finance Controls Policy v3 §4.2. Decision is written to audit history. Access requests are explicitly out of scope.

ACCEPTANCE CRITERIA
Manager receives a notification for a pending expense
Manager can approve or reject from the notification
Expenses over $5,000 require second-level approval (manager + Finance)
Employee is notified of the decision
Decision is recorded in audit history

expense-approvals
first-release
compliance
5 pts

From conversation to code.

Interface text:
Product requirements review · live
Pause
Replay

### The specification updates live

After Sam confirms Dana’s proposed change, the demo updates both the goal and REQ-142 to require second-level approval for expenses over $10,000.

[17:08](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=1028s) [After confirmation, the goals and work item show the updated expense approval threshold.](https://assets.ai.engineer/sites/aiecode2025/sha256/04708a8d7fc7319a94cc6a553691b26a099288a9da1fb72226e873ae383158f6.webp)

Product requirements review · live

Sam — answer
Yep — manager plus Finance.

Jordan — proposal
So a big one can't be a single tap.

Sam — agree
Right — over the limit it routes to a second approver.

Dana — agree
Agreed. Under five, one tap's fine.

Jordan — agree
Works for me.

Sam — closing
Okay — agreed. Expense approvals, five-thousand threshold.

Sam — directive
AI, capture that for us.

Dana — proposal
Actually — make the threshold ten thousand, not five.

AI — question
Want me to update the requirement to a ten-thousand threshold?

Sam — answer
Yes.

Jordan
AI — is this room free after the meeting?

CHAT
SAM
what's our current median approval time?

AI
2.3 days median right now; the target is same-day.

SAM
right, that's fine

GOALS
Q: Which requirement is this?
REQ-142 — expense approvals
Resolve approval scope
Expense approvals — first release
Apply $10,000 second-level threshold
Access requests — future scope
Q: Is the $5,000 threshold still current?
Answered — raised to $10,000 (Sam confirmed)

REQ-142 — TO DO
Approve / reject expense requests from a notification

First release: managers can approve or reject pending expense requests directly from a notification. Expenses over $10,000 route to second-level approval per Finance Controls Policy v3 §4.2. Decision is written to audit history. Access requests are explicitly out of scope.

ACCEPTANCE CRITERIA
Manager receives a notification for a pending expense
Manager can approve or reject from the notification
Expenses over $10,000 require second-level approval (manager + Finance)
Employee is notified of the decision
Decision is recorded in audit history

expense-approvals
first-release
compliance
5 pts

It updates the spec — live.

Interface text:
Pause
Replay
Dana — Stakeholder
Sam — Product · Lead
Jordan — Engineering
SPEAKING

### AI participates in the meeting

In the demo, the AI asks to update the expense threshold to $10,000, and Sam confirms. It then answers a separate question about the room being available until three.

[17:14](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=1034s) [The meeting conversation continues with the AI answering a question about room availability alongside the updated work item.](https://assets.ai.engineer/sites/aiecode2025/sha256/457b6bc615abdf6b1be958d04179a076169f029db68d59a97307b660ef8de47a.webp)

Product requirements review · live

Dana
Stakeholder
Sam
Product · Lead
Jordan
Engineering

Dana · agree
Agreed. Under five, one tap's fine.

Jordan · agree
Works for me.

Sam · closing
Okay — agreed. Expense approvals, five-thousand threshold.

Sam · directive
AI, capture that for us.

Dana · proposal
Actually — make the threshold ten thousand, not five.

AI · question
Want me to update the requirement to a ten-thousand threshold?

Sam · answer
Yes.

Jordan · question
AI — is this room free after the meeting?

AI
Let me check — the room looks free after this, but—

Sam · question
Until three?

AI
Yes — it's yours until three o'clock.

CHAT
SAM
what's our current median approval time?
AI
2.3 days median right now; the target is same-day.
SAM
right, that's fine

GOALS
Q: Which requirement is this?
REQ-142 — expense approvals
Resolve approval scope
Expense approvals — first release
Apply $10,000 second-level threshold
Access requests — future scope
Q: Is the $5,000 threshold still current?
Answered — raised to $10,000 (Sam confirmed)

REQ-142 · TO DO
Approve / reject expense requests from a notification

First release: managers can approve or reject pending expense requests directly from a notification. Expenses over $10,000 route to second-level approval per Finance Controls Policy v3 §4.2. Decision is written to audit history. Access requests are explicitly out of scope.

ACCEPTANCE CRITERIA
□ Manager receives a notification for a pending expense
□ Manager can approve or reject from the notification
□ Expenses over $10,000 require second-level approval (manager + Finance)
□ Employee is notified of the decision
□ Decision is recorded in audit history

[illegible]approvals · first-release · compliance · 5 pts

Participation — during the work, not a prompt after it.

Interface text:
Pause
Replay

### Loops, Prompts, Agents

Loops, prompts and agents still constrain the interface. The slide points toward AI interfaces that converse, use context, and choose the right affordance, timing or silence.

[17:35](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=1055s) [Slide contrasts loops, prompts, and agents with interfaces that support conversation, multimodality, context awareness, appropriate affordances, timing, and silence.](https://assets.ai.engineer/sites/aiecode2025/sha256/d58a25f9a920c3ecd76f5373f437f77948ef2a435a6b4b370f7c130fcbfee4c3.webp)

Loops, Prompts, Agents...
useful patterns — but still constraining the interface

TODAY: CONSTRAINED PATTERNS

1 LOOPS
> predefined flow
> hard-coded steps

2 PROMPTS
> manual context
> submit + repair

3 AGENTS
> delegated tasks
> still shaped by old affordances

BEYOND THE CONSTRAINT
conversation
multimodal
context-aware
right affordance
timing
silence when useful

Design for what is possible, not just what old interfaces allow.

## Full transcript

[0:00](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=0s) [upbeat music] I'm sure that sometime in the last few hours, most of you did this. You typed a request into a small box to a superintelligence, and then you waited.

[0:16](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=16s) You watched the cursor blink, maybe a little throbber cycled through clever gerunds like hullabalooing, tomfoolering, and philosophizing to hide the wait. Maybe it gave you what you wanted, maybe you rephrased it and tried again.

[0:32](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=32s) It all felt completely normal. I wanna spend the next twenty minutes making prompting feel unfamiliar and strange again. I'm Ted Johnson, co-founder of JoinIn AI. During my twenty-five-year career building enterprise software, collaboration systems, and AI-enabled interfaces, I've always focused on human interaction.

[0:53](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=53s) I've also been following AI for two decades, including back to the far less impressive GPT-1 and 2. And when ChatGPT arrived, I felt two things at once. First, and unsurprisingly, amazement, knowing the world would never be the same, followed by actually surprising disappointment I couldn't shake.

[1:13](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=73s) This disappointment turned into an observation that started a company, JoinIn AI, and that I keep coming back to, which is, why do we still have to learn AI? Why does something s- this powerful so often feel unnatural to use?

[1:29](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=89s) Here's the path we'll take to answer that. We'll start with the most familiar computer interface and make it strange again. Then I'll give you three key concepts, the channel, the physical transport that carries your intent, expression, the range and richness of meaning the channel can carry, and the protocol, the shape or rules of this exchange.

[1:51](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=111s) I'll use those three concepts to show you that the prompt is our present-day punch card. We'll share examples of the ways interfaces could progress, and we'll wrap with some practical advice for AI and human-centered design.

[2:07](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=127s) Everyone knows what this is, the keyboard. It's everywhere, and it feels completely normal or natural,

[2:14](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=134s) but it isn't. We all had to take lessons. We all had to practice. And I say this as someone who loves keyboards, but it seems that we've been trying to fix them as long as they've been around.

[2:25](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=145s) People have tried more efficient layouts like Dvorak or Colemak to save their fingers some work. A more extreme, uh, example, some keyboard enthusiasts refuse to squander their two digits on the space bar, giving them four or eight or ten keys, uh, to press with that efficient thumb of theirs.

[2:44](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=164s) And what do we even mean by the keyboard? Here's the patent drawing for the layout we use every day. This patent's from about 1860. And my personal favorite, it just as could have easily been the Hansen Writing Ball, which looks anything but like a way you wanna talk to a superintelligence.

[3:03](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=183s) We carry these legacies of an arbitrary input device designed under constraints that haven't existed for a century, and we put it between ourselves and the most capable machines ever built.

[3:13](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=193s) Nobody alive chose it. We all inherited it, and then we stopped noticing. So that's the first idea, the channel, the medium an interface gives you to work in. A keyboard is a channel, a microphone, channel, a screen, a punch card, a prompt box, all channels.

[3:30](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=210s) And channels matter because each one can physically carry a different kind of signal. For example, text is a stream of discrete symbols. Voice can carry timing, pitch, hesitation, and words.

[3:42](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=222s) A diagram can carry spatial relationship all at once. But these are differences in what the medium can transmit, its bandwidth, not the differences in the meaning. And carrying more signal isn't the same as the machine understanding any of it.

[3:58](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=238s) That's a separate question. That's the next idea. Humans use all these channels constantly without thinking. We never pick one channel and force everything through it. That would be absurd.

[4:09](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=249s) And yet, that's what we ask people to do with machines over and over. Hold on to the word channel because here's the plot twist. With AI, the channel never really changed.

[4:20](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=260s) You're still typing into a box, but what you were allowed to push through it was about to. For the first time, the computer channels carry rich, complete human language.

[4:30](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=270s) Notice I said what it carries, not what it is. You're still typing into a box. You're still hitting the Submit button. The keyboard didn't change. What improved is the range of what you're permitted to express through it.

[4:43](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=283s) There's the second idea, expression, how much of what you actually communicate or mean will go through the interface. That's the second idea, expression, how much of what you actually communicate or mean will the interface let through.

[4:58](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=298s) Here's an example of expression progress over time with computers. Starting with assembly, which gave you an instruction set, a few dozen opcodes, then came the sh- uh, commands with the shell, inputs, flags, then modern programming languages gave you primitives that you could compose.

[5:17](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=317s) While powerful step by step, each one of these is a fixed vocabulary requiring you to express your intent by choosing from a menu the machine will accept. Natural language blew that menu open.

[5:29](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=329s) For the first time, you can say almost anything the way you'd say it to another person. And on the expression axis, the leap is real and enormous. There's an ocean of meaning in an ordinary human request, context, nuance, intent, all things we've never had to spell out to each other.

[5:47](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=347s) For the first time, you can say almost anything the way you'd say it to another person. For the first time, a machine can take it in. So here's what should bother us as engineers and designers, as it's bothered and inspired me, the channels for computers have been the same for fifteen years, some a hundred and eighty years.

[6:05](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=365s) Now, with AI, we've poured an ocean of expression into it. So why does it feel like we're still sipping through a straw and struggling to learn how the AI thinks?

[6:14](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=374s) Because there's a third idea underpinning the other two, and it's really the one that hasn't kept up, the protocol, the rules you follow, and the shape of the interaction itself.

[6:26](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=386s) Channel stayed the same. Expression exploded in the last three years with LLMs, but the protocol, prompting, is the protocol of a punch card, and the punch card's protocol is good old batch.

[6:38](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=398s) Here's what punch card batch meant. You sat down, away from the machine, carefully encoded your entire request in advance, carried your deck to the operator, you submitted the job, and then you waited, sometimes hours, sometimes overnight.

[6:54](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=414s) Then you read the printout, found one thing that was wrong, fixed it, resubmitted it, and waited again. The machine never engaged with you while you were thinking. It engaged with the finished package after the fact.

[7:08](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=428s) Now let's look at the prompt. Assemble the whole request, submit it, wait, read what comes back. Something's off, assemble it again, submit again, and wait. We have to acknowledge that there are features, interactive features improving this.

[7:23](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=443s) You can ask for updates. You can ask for summaries of what was done. But in the end, it's still batch with interactive sprinkles. It's the same protocol. We shrank the wait time from overnight to a few seconds or a few minutes, and the speed fooled us into thinking that it had become interactive.

[7:41](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=461s) It hasn't. It's still batch. You still package a complete turn before the machine is allowed to participate. We learn tricks, send tips to use code skills or rewrite prompts a certain way to manage this.

[7:54](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=474s) And speaking doesn't change it. Your voice just gets transcribed into the box and submitted. Shorter batch is still batch because the protocol is the part that did not advance.

[8:04](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=484s) The protocol is the part we've had to learn. We just gave it a flattering name. We call it prompt engineering and treat it like it's a power user skill.

[8:12](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=492s) Strip the label off, and it's a set of rules for packaging up good old batch. For example, tell it to think step by step. Give it examples. Ask it to be an expert.

[8:23](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=503s) Don't ask it to be an expert. Don't ask it that way. Paste more context. Paste less context. Only talk to it through markdown documents. We trade incantations. We've learned the magic words.

[8:36](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=516s) That's the illusion. It feels like mastery, but it's the same sort of mastery a punch card operator had, knowing exactly how to assemble the deck so the job wouldn't fail.

[8:45](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=525s) Moreover, we've gotten good at prompting for these black boxes, and, and that's the part that should bother us, not reassure us. None of this means prompts are bad. Punch cards weren't bad.

[8:55](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=535s) Command lines aren't bad. They're brilliant solutions for constraints of their time. But that's the whole question. Is batch still the right protocol? Are we still prepackaging our intent for a machine that no longer needs us to?

[9:08](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=548s) Because it shouldn't need us anymore. It can ask a follow-up. It can clarify mid-thought. It can notice it's missing something and say so. It should be human conversational. Sherry Turkle of MIT puts it very well: Conversation is the most human and humanizing thing we do.

[9:26](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=566s) It's one of humanity's superpowers. The capacity to engage and think is right there, and yet we're still making people submit the deck and wait for the run. Even the punch card inherited its protocol, in fact.

[9:39](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=579s) Batch came from the weaving loom. You set the whole pattern in advance, then ran the cloth. The punch card got reused on computers by default. We're still standing at the same moment again.

[9:51](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=591s) AI could finally meet us in the middle of a thought, got handed a protocol of a loom. That's what I mean. The prompt is still a punch card, not because of how you encode it, the encoding is powerful and awesome, because when the LLM is allowed to engage only after you've packaged a complete turn and submitted it,

[10:10](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=610s) and this is where the mismatch bites. Model capacity is shooting straight up. Reasoning, speech, vision, memory, planning, all curving upwards. The interface protocol, flat. Still a box, still a submit button, still the human doing all the work around the LLM.

[10:26](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=626s) The human still decides what context matters, still remembers what to ask, still chooses the timing, still notices the ambiguity, still repairs the output, still has to carefully engineer a prompt.

[10:37](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=637s) But the intelligence feels magical. It's the interface that still feels like work. And when it feels like work, when the output's wrong, when the magic words don't land, people blame themselves.

[10:48](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=648s) They decide they're bad at this. They're not specific enough. They don't get AI. I want to say as clearly as I can, it is not our fault. We are not bad at using AI.

[10:58](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=658s) We are being asked to operate a brand-new kind of intelligence through a protocol of a punch card. The mismatch isn't the user, it's the interface. In the race to enable AI, we shortcut the interface.

[11:09](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=669s) Okay, let's make this concrete and familiar. A few weeks ago, my co-founder was using a frontier company's voice mode. These are known as speech-to-speech models.

[11:21](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=681s) He asked it a normal question, "When is the next Timberwolves game?" Fine. It answered it quickly. Then he pretended I showed up as if to speak to me and said, "Hey, Ted, come on in."

[11:34](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=694s) He wasn't talking to the AI, but these models have no way to know that. So the AI did the only thing a prompt box can do. It took his speech as a turn and answered it.

[11:47](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=707s) "Sure, I'm here. What's on your mind?" That's not a good answer, but it's not a dumb model. It answered the first question perfectly, but it's a protocol with exactly one slot, your message, then its reply.

[12:01](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=721s) It has no concept of who's speaking, whether the words were even meant for it. And the frontier companies want to make strides as well. OpenAI released GPT Realtime 2 in late May and started trying it for their voice mode as well.

[12:16](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=736s) It backchannels now. It goes, "Mm-hmm," and, "Right," the little sounds we make to show we're listening actively. We're seeing the field is converging on the same conclusion we built our company on: the interface has to stop being batch and start participating.

[12:33](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=753s) Others are working on real-time conversation as well. This is NVIDIA's PersonaPlex, a research model, not ours. Watch what happens when it gets interrupted.

[12:44](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=764s) I've been thinking about starting a diet.

[12:46](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=766s) Yeah, starting a diet can feel a bit daunting, but you could keep it simple. Focus on eating more veggies and fruits. Try to-

[12:53](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=773s) Oh, before I forget, I signed up for a marathon.

[12:56](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=776s) All right. Congrats on signing up for the marathon. That's a big challenge. You've got a lot of time. Focus on building a solid base with regular long runs. Stay hydrated.

[13:05](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=785s) Make sure you fuel right before and after, and don't forget to stretch and take care of your feet.

[13:10](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=790s) PersonaPlex stops. It yields. It picks the thread back up. That's real turn-taking, listening and speaking at once in real time.

[13:21](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=801s) You need to come visit me-

[13:22](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=802s) Oh, okay

[13:23](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=803s) ... 'cause then we can go into the city.

[13:24](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=804s) Okay.

[13:25](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=805s) 'Cause that's the thing, like-

[13:26](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=806s) Yeah

[13:26](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=806s) ... there's, like, the random spray paint, but then there's also, like...

[13:30](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=810s) I, I'm not su- people must commission them-

[13:33](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=813s) Yeah, I think they do

[13:34](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=814s) ... like these massive, like, mural spray paint pieces.

[13:36](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=816s) Yeah.

[13:36](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=816s) Um-

[13:37](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=817s) I think they do

[13:38](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=818s) And PersonaPlex backchannels, listens, and lands where a person's would.

[13:44](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=824s) Beyond conversational flow, there are lots of challenges, and it's a complex problem. Making listening noises is not really the same as knowing who's in the room. These are s- not trained to tell that, "Hey, Ted," wasn't meant for it,

[14:01](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=841s) but we are. We're working on improving the protocol to the models by giving it a better understanding of human and group conversation.

[14:10](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=850s) Good afternoon, everyone. Good afternoon, Sam. Hi, Jordan.

[14:17](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=857s) Good afternoon. Good to see you both.

[14:20](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=860s) Quick one. Which requirement is this? Do we have an ID?

[14:24](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=864s) This is [REDACTED:generic_id], expense approvals.

[14:28](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=868s) There, it answered a question. It only takes actions based on the utility-driven model, so it creates goals to fulfill as it labels each of the participants' statements as a question, a proposal, an answer, and then only takes a turn when no one else is speaking or holding the floor.

[14:47](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=887s) Right. We need users to approve requests faster. Yeah. The approval flow's too slow.

[14:56](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=896s) What kind of requests, though?

[14:58](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=898s) Expense approvals first, access requests eventually. AI, hold that.

[15:12](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=912s) Actually, let's pause. Expense approvals or a general approval workflow? Expense approvals, first release. Access requests are future scope.

[15:25](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=925s) That changes the data model. Good to know.

[15:31](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=931s) AI, pull that up for everyone.

[15:33](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=933s) Tracking, determining who s- the speaker's referring to is critical. In this case, it was easy with a direct reference to the AI, but it'll happen again without a direct a- reference.

[15:44](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=944s) Oh, I'd forgotten that was a rule.

[15:46](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=946s) So over 5,000 needs a second approver? Yep, manager plus finance.

[15:53](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=953s) So a big one can't be a single tap.

[15:56](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=956s) Right. Over the limit, it routes to a second approver. Agreed. Under five, one tap's fine.

[16:03](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=963s) Works for me.

[16:09](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=969s) Okay. Agreed. Expense approvals, 5,000 threshold.

[16:17](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=977s) Right there, the AI resolved the scope objective. No one wrote the prompt. No one packaged the turn and hit Submit. The system was in the conversation, following it, understanding, and choosing its moment.

[16:31](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=991s) AI, capture that for us.

[16:34](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=994s) First release supports expense approvals only. Access requests are out of scope. Managers can approve or reject an expense right from a notification.

[16:43](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=1003s) And per the finance controls policy, anything over $5,000 routes to a second approver.

[16:59](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=1019s) Actually, make the threshold 10,000, not 5,000.

[17:03](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=1023s) Want me to update the requirement to a 10,000 threshold?

[17:06](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=1026s) Yes.

[17:09](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=1029s) AI, is this room free after the meeting?

[17:12](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=1032s) Let me check. The room looks free after this, but-

[17:16](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=1036s) Until 3:00?

[17:16](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=1036s) Yes. It's yours until 3:00.

[17:19](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=1039s) And that's the difference between a smart machine behind the same old prompt and an interface that finally participates. Here's the mindset shift I wanna leave you with: AI is not just an intelligence technology.

[17:33](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=1053s) It's increasingly becoming an interface technology, and if so, then book-smart models alone are not enough. Stop picturing AI as a smarter machine hiding behind prompts, agents, loops, and a- all the old paradigms.

[17:47](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=1067s) We have to start seeing intelligence itself as a thing that can finally remove interface constraints and amplify human potential. For 75 years, humans adapted the, to the machine, its syntax, its forms, its timing, its batch.

[18:03](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=1083s) A system that can reason, listen, infer, adapt should be able to meet us partway, if not all the way. Instead, if AI is for users, then we should obsess about maximizing the interface.

[18:16](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=1096s) So then the design question changes. It needs to become, what burden are we still putting on humans only because the machine used to be too limited to carry that burden itself?

[18:27](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=1107s) Ask that question, and the whole interface space opens up. The answer isn't always chat. It isn't always voice and not a wall of markdown. It's definitely not a decade-old set of digital constructs.

[18:41](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=1121s) The right answer is the affordance humans already use with each other: communication, a question, a pause, a sketch, a checklist, a quiet aside, or saying nothing at all. An interface where timing and modality aren't the human's job anymore, where choosing the right channel at the right moment is done by the AI.

[19:03](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=1143s) And as a usability person, this is the part that excites me the most. When you take that burden off people, the friction disappears and adoption follows. Computing has mostly been about, to date, improving how humans encode their intent for machines.

[19:19](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=1159s) The punch card, type a command, click a menu, use your thumb on an iPhone, write a prompt. Every step was progress, and every step carried the old constraint forward into the next era.

[19:30](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=1170s) A translation tax, a precision tax, context tax, repair tax. AI is our chance to put those down, not by making everything magical, not by making everything voice, not by replacing human judgment, but by making computers, for once, more fluent with us.

[19:49](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=1189s) Most talks and videos cover how to use or adopt AI. The deeper question is how AI intelligence changes the interface. Human conversation is the most human thing we do because if a machine can finally understand more of what we mean, then we can and should stop reshaping ourselves to be understood by it.

[20:09](https://www.youtube.com/watch?v=hVJOnuhFmTA&t=1209s) Thank you.
