OpenAI Computer-Use Agents Beat Human Speed Across Legacy Software
Seema Amble, Fabrizio Serafini, Ari Weinstein, James Sun
Universal computer-use agents are surpassing human operating speeds, enabling enterprises to automate legacy workflows directly through existing interfaces without custom APIs or connectors.
OpenAI reports that computer-using agents have surpassed the average human operator in speed and are approaching superhuman execution levels, shifting manual computing from the default approach to an intentional exception. (8:32)
Computer use provides a universal runtime that manipulates standard user interfaces directly, bypassing the need for dedicated developer APIs, connectors, or custom Model Context Protocol (MCP) servers. (14:04)
OpenAI deploys an independent oversight model named Guardian alongside deterministic enterprise sandboxes to inspect proposed actions and require sign-offs before execution on high-risk domains or file operations. (10:00)
The next major consumer distribution milestone centers on provisioning headless, cloud-hosted computers accessible through mobile chat interfaces, decoupling desktop-level automation from physical desktop hardware. (41:15)
Detailed notes
## Background
Published on October 26, 2026, via RSS by a16z with hosts Seema Amble and Fabrizio Serafini, this episode features OpenAI's Ari Weinstein and James Sun. According to the page description, the discussion explores how computer-using AI agents are entering a scaling inflection point by outperforming humans at operating graphical software, navigating legacy enterprise systems without custom APIs, and shifting toward proactive background collaboration.
## TL;DR
OpenAI's Ari Weinstein and James Sun break down how recent model advances like Astra allow AI agents to operate software faster than average humans directly through graphical user interfaces. By eliminating the traditional integration tax, computer use enables agents to execute complex workflows across legacy ERPs, financial reconciliations, and consumer tasks without custom APIs or MCP servers. To manage superhuman execution safely, enterprises rely on deterministic sandboxing and oversight systems like Guardian, while founders find durable moats in vertical domain workflows. Looking ahead, the speakers detail a shift from isolated, desktop-bound tools toward proactive, cloud-hosted agents that seamlessly bridge fragmented interfaces and anticipate user needs.
## Atmosphere & style
The conversation carries the pragmatic, insider energy of builder-founders operating at the frontier of AI infrastructure. Hosts Seema Amble and Fabrizio Serafini foster an engaging, inquisitive dialogue that balances venture-scale strategic analysis with candid technical reflections from Weinstein and Sun. The mood is warmly intellectual and grounded, punctuated by lighthearted personal anecdotes—such as defending Apple Numbers, observing the 'cute' Codex cursor, and coding custom board-game trainers—that make high-stakes architectural debates feel approachable and human.
## Bulletin
- `08:32` OpenAI reports that computer-using agents have surpassed the average human operator in speed and are approaching superhuman execution levels, shifting manual computing from the default approach to an intentional exception.
- `14:04` Computer use provides a universal runtime that manipulates standard user interfaces directly, bypassing the need for dedicated developer APIs, connectors, or custom Model Context Protocol (MCP) servers.
- `10:00` OpenAI deploys an independent oversight model named Guardian alongside deterministic enterprise sandboxes to inspect proposed actions and require sign-offs before execution on high-risk domains or file operations.
- `41:15` The next major consumer distribution milestone centers on provisioning headless, cloud-hosted computers accessible through mobile chat interfaces, decoupling desktop-level automation from physical desktop hardware.
## Key takeaways
- `00:00` Astra delivers significant token efficiency and tighter alignment, hardening computer-use agents against prompt injection and enabling complex visual tasks such as drawing in Microsoft Paint and playing video games.
- `05:00` Enterprise adoption prioritizes operating legacy software and 15-to-20-year-old ERPs lacking APIs, while consumer adoption centers on autonomous cloud machines handling personal digital friction.
- `06:20` Proactive background agents can execute multi-step diagnostic workflows autonomously, such as reconciling missing calendar invites or detecting Slack alerts, fetching logs from Sentry, and analyzing them in Codex.
- `10:00` As agents reach superhuman execution speeds, visual real-time human auditing becomes unfeasible, requiring automated safety systems like the Guardian model to verify actions against user intent.
- `12:00` Autonomous browsing introduces tensions with ad-supported web publishers whose models rely on human page impressions, prompting collaborative frameworks like WebMCP that keep users in control of high-taste decisions while delegating execution.
- `14:04` Computer use fundamentally removes the 'integration tax' for automation by operating applications through front-end visual controls exactly as a human employee would.
- `17:15` Enterprise trust depends on a dual-layer safety architecture that pairs internal model alignment with deterministic administrative boundaries, such as application whitelisting and mandatory human confirmations for file transfers.
- `20:00` Legacy enterprise operations—including multi-department procurement handoffs, month-end financial reconciliations across disjointed ledgers, and sales prospecting—represent primary opportunities for computer-use agents.
- `25:00` The emergence of computer-using agents will simultaneously preserve legacy systems by operating existing interfaces and spur hyper-personalized, artisanal front-ends tailored to niche user preferences.
- `30:00` To prevent ecosystem fragmentation where every site runs an isolated assistant, agents must integrate through a shared intelligence layer that bridges context across separate applications.
- `32:51` Early-stage startup moats lie in deep vertical domain expertise, workflow integration, and customer servicing, as frontier labs remain resource-constrained across fundamental research priorities.
- `37:25` A key product hurdle is UX state fragmentation between local browser extensions, desktop client browsers, and remote cloud virtual machines.
- `40:00` The long-term UX vision transitions from requiring users to master prompt engineering and manually trigger agents to an environment where proactive agents anticipate context while users retain high-level steering.
- `41:15` OpenAI experienced an inflection in adoption after moving away from standalone agent browsers like Atlas to embedding computer-use capabilities directly into existing agent workflows and cloud infrastructure.
## Detailed walkthrough
### `00:00` Introduction and What Astra Unlocks for Computer Use
The discussion opens with highlights contrasting human and agent performance: computer-using agents have already surpassed the average human in speed, are closing in on superhuman capability, and—unlike traditional developer tooling that requires custom connectors or Model Context Protocol (MCP) servers—work universally across existing user interfaces. Hosts Seema Amble and Fabrizio Serafini from Andreessen Horowitz (a16z) introduce OpenAI's Ari Weinstein and James Sun to unpack the recent milestones and the road ahead.
Ari Weinstein explains how the release of Astra refines computer use. While earlier models were already proficient, Astra elevates the edge cases in subtle but decisive ways:
- **Token Efficiency and Speed**: It consumes fewer thinking tokens for the same workload, noticeably increasing execution speed.
- **Creative and Visual Capabilities**: It handles nuanced graphical operations, exemplified by launch demos where it drew dynamically inside Microsoft Paint following natural language instructions.
- **Perceptual Reliability**: Ari highlights the compounding value of edge-case reliability: “It's sort of the kind of thing where there's a little difference that is hard to perceive, but really important between something being 99% reliable and 97% reliable.”
James Sun reinforces this from a systems and safety perspective, pointing out that Astra is OpenAI's most aligned model to date:
- It significantly hardens defenses against prompt injection and curbs unintended autonomous actions, making it viable for high-stakes enterprise workflows like procurement and direct customer interactions.
- On the reasoning and real-time execution side, James notes internal benchmarks where Astra competed in video games against previous models (like 5.6) and won every match, with community benchmarks demonstrating it beating complex titles like *Fallout* in roughly 30 hours.
```mermaid
flowchart TD
accTitle: Astra Core Improvements
accDescr: Key upgrades introduced in Astra spanning efficiency, safety, and operational reliability.
subgraph AstraUpgrades["Astra Capabilities"]
A["Fewer Thinking Tokens"] --> B["Faster Real-Time Execution"]
C["Tighter Alignment & System Card"] --> D["Prompt Injection Resistance & Safety"]
E["Visual & Reasoning Precision"] --> F["Complex GUI Navigation (Paint, Gaming, ERPs)"]
end
B --> G["Enterprise & Consumer Readiness"]
D --> G
F --> G
```
---
`05:00` Enterprise Realities vs. Consumer Frontiers
When comparing consumer and enterprise adoption, Ari and James draw a clear contrast based on UI constraints and operational goals:
1. **Enterprise Applications**: Enterprise software is dominated by legacy platforms (like ERP systems) that have persisted for 15 to 20 years without APIs or modern MCP endpoints. These systems feature dense, unintuitive user interfaces that human employees find difficult to navigate. Rather than undertaking massive integration rewrites, companies are developing agent "skills" that instruct the model on navigating and operating legacy screens directly. James points out: “Inside enterprises, there's lots of legacy software that doesn't have any MCP tools.”
2. **Consumer Frontiers**: Consumer use cases focus on offloading personal friction and everyday digital chores. Ari highlights how autonomous assistants like Dot give each user a personal cloud machine equipped with a full web browser capable of buying goods, booking haircut appointments, and handling mundane online tasks independently.
---
`06:20` Proactive Personal Agents and the Dot Workflow
James Sun shares concrete ways proactive agents run inside OpenAI to eliminate daily friction across personal and developer workflows. A key advantage of these agents is their ability to act on loosely structured goals rather than rigid rules:
- **Calendar & Email Reconciliation**: Internal email routing frequently failed to propagate calendar invites sent from outside the company. The agent monitors incoming mail, identifies calendar disconnects, and proactively asks for permission to accept the invite via Gmail so meetings do not fall through the cracks.
- **Noise Reduction & Incident Triaging**: Traditional Slack cron jobs and automations overwhelmed him with notifications. Instead, James configured the agent with high-level guidelines (e.g., alert him when someone in his reporting line posts or when critical product feedback arrives).
```mermaid
flowchart LR
accTitle: Agent Automated Triage Workflow
accDescr: An end-to-end triaging loop run by an agent combining local and cloud compute.
subgraph Trigger["Monitoring"]
A["Slack Message"] --> B{"Matches High-Level Goal?"}
end
subgraph Investigation["Automated Investigation"]
B -- "Yes" --> C["Cloud Computer Launches Browser"]
C --> D["Log into Sentry"]
D --> E["Extract Error Logs"]
end
subgraph Resolution["Analysis"]
E --> F["Feed Logs to Codex"]
F --> G["Deliver Synthesized Analysis to User"]
end
```
By leveraging both a cloud machine and the user's local workstation, the agent closes the loop autonomously—detecting the issue in Slack, opening Sentry in the cloud browser, downloading the corresponding diagnostic logs, piping them into Codex, and returning a synthesized assessment without human intervention.
---
`08:32` Speed, Superhuman Execution, and Changing User Behavior
Ari discusses how OpenAI balances speed, token efficiency, and reliability. While computer use often runs asynchronously in the background—where wall-clock latency is less critical—latency becomes vital whenever a human is waiting in real time or supervising a sensitive action. If an agent operates too slowly, users experience the friction of feeling they could have executed the task faster themselves.
Ari explains that agents have already surpassed typical human performance and are nearing a broader inflection point:
- “We've gotten computer use now to a place where it's faster than the average human at using a computer.”
- “And I think we're getting really close to a place where it is superhuman, meaning it is faster than an expert computer user like probably one of us at this table.”
Ari argues that crossing the superhuman threshold will fundamentally alter how individuals interact with computing hardware: when delegating to an agent becomes faster than manual entry, manual control will shift from the default approach to an intentional exception. To serve these varying performance and cost profiles, OpenAI continues pursuing a multi-model portfolio strategy.
`10:00` Enterprise Controls, Model Tiers, and Guardian
As computer-use models proliferate across various price points and capabilities, developers and enterprises face a fundamental trade-off between execution speed, reliability, and human oversight. When an agent runs slowly, users can supervise its steps visually, but doing so negates the efficiency gains of automation. Conversely, once an agent executes tasks at superhuman speeds where real-time human auditing becomes impossible, enterprises require rigorous governance frameworks. To address this, OpenAI introduced enterprise controls and an oversight model called Guardian to monitor actions deterministically.
```mermaid
flowchart LR
accTitle: Computer-Use Agent Action Evaluation Flow
accDescr: Shows the agent generating an action, Guardian verifying safety against intent, and branching to auto-approval or human review.
subgraph Execution["Agent Execution"]
A["Agent Generates Action"]
end
subgraph Oversight["Safety Layer"]
B["Guardian Oversight Model"]
C{"Safe & Aligned to Intent?"}
end
subgraph Resolution["Action Outcome"]
D["Auto-Approve Action"]
E["Human-in-the-Loop Review"]
end
A --> B
B --> C
C -->|"Yes (Consumer/Trusted)"| D
C -->|"No / High-Risk Policy"| E
```
Ari Weinstein highlights that lower-cost models are rapidly improving at computer use, expanding the range of tiers customers can deploy across different jobs. Meanwhile, James Sun points out that autonomy must be tunable based on risk tolerance: “We have this really awesome system called Guardian, I think auto-approve in the app, that is a really smart model looking at every single action that the computer use agent is taking to decide if it's safe, if it's aligned to their original intent.” While everyday consumers may prefer fully automated execution without friction, business administrators demand the ability to configure precise thresholds for human approval.
- **Model diversity**: Lower-cost, smaller models are rapidly closing the capability gap for computer-use tasks, allowing organizations to route workloads dynamically by cost and complexity.
- **The auditability dilemma**: Slow agent execution is easy to audit visually but inefficient; superhuman execution speed provides high leverage but demands automated safety guardrails.
- **Guardian safety system**: An independent, dedicated model inspects every discrete step an agent proposes before execution to verify alignment with original user intent.
`12:00` Website Publisher Business Models and WebMCP
The transition toward autonomous web-browsing agents creates sharp divisions across the software and media ecosystem. For internal enterprise applications, automation is universally embraced because it directly reduces employee drudgery. However, the public web presents conflicting incentives: publishers and ad-driven sites rely on human eyeball impressions to monetize traffic. Since automated agents clicking on links or extracting data do not register as valid ad revenue, legacy publisher business models are directly challenged by autonomous browsing.
At the same time, companies eager to accommodate agentic traffic are looking toward hybrid integration models. James Sun highlights emerging frameworks like WebMCP, which provide structured pathways for people and agents to operate within the same web environment. Rather than removing the human entirely, this architecture allows users to enjoy consumer-facing experiences—such as browsing hotel selections, flights, or fashion products—while offloading data scraping, form filling, and repetitive navigation to the agent. When it is time to finalize checkout or enter payment details, the agent smoothly hands execution back to the user without needing custom APIs.
- **Ad-supported web tensions**: Agentic traffic does not generate recognized ad impressions, creating business model conflicts with traditional publishers and advertising platforms.
- **WebMCP adoption**: An open standard supported directly in the in-app browser, enabling agents and humans to collaborate within standard web pages without custom back-end APIs.
- **Collaborative browsing workflows**: The user retains control over high-taste or leisure phases (e.g., browsing flights or shopping), while the agent handles repetitive operations and transaction execution.
`14:04` Computer Use as a Universal Interface
When evaluating which workflows are mature enough to delegate to agents, the boundaries between narrow automation and complex work are dissolving. With recent model updates, agents can handle broad natural-language instructions, clarify ambiguous instructions using flexible input prompts, and automatically pull necessary context if the user fails to respond immediately. As long as a task does not involve hyper-sensitive communications where personal voice is paramount, modern agents can handle almost any computer-based workflow.
Ari Weinstein underscores that computer use fundamentally differs from prior automation paradigms because it eliminates the integration tax. Instead of waiting for third parties to write connectors or launch API endpoints, computer-using models simply operate the front-end software interface identically to a human worker:
> “The really cool thing about computer use as a technology is the universality of it. You know, it works with every application. It's unlike any other thing that we've built where, you know, the developer has to do some work to adopt it. Someone has to build a connector or MCP server. You know, computer use works with everything. And it works by using the application the same way a human uses it, which I think is something worth understanding if you haven't spent much time with this technology.”
James Sun adds that he no longer compartmentalizes work into "computer-use" versus "non-computer-use" buckets. Instead, computer use functions as the underlying runtime for all digital actions. The only friction remaining is tiny, two-click micro-tasks where launching an agent takes more effort than manual execution—a barrier that is quickly disappearing as voice interfaces and agent execution speeds accelerate.
- **Universal software runtime**: Computer use operates through standard graphical user interfaces (GUIs), removing the need for dedicated developer integrations or bespoke APIs.
- **Flexible input handling**: When encountering ambiguous requirements, modern agents ask proactive follow-up questions, falling back to contextual inference if the user does not intervene.
- **Human parity**: Because the agent views and manipulates UI controls the same way a person does, any workflow executable by an employee is inherently accessible to the model.
`17:15` Deterministic Sandboxing and Building Enterprise Trust
Despite model intelligence reaching state-of-the-art levels, enterprise leaders remain hesitant about accountability, unauthorized actions, and prompt injections. To overcome this skepticism, enterprise deployment cannot rely solely on the model's internal safety alignment; it requires deterministic, policy-level boundaries that constrain what the agent can physically access.
James Sun explains that OpenAI structures enterprise safety into two distinct layers:
> “The first layer is like, how do we create deterministic controls? I think that's really what gives, you know, enterprises a lot of feeling of safety is when they can, even though our model is the most aligned ever... But I think there is just the feeling of safety when the enterprise admins can basically say for certain tasks or for certain data sources, used.”
Administrators can establish strict sandboxes that whitelist permissible software and websites, alongside policy triggers that mandate explicit human sign-off for file uploads, downloads, or navigation to unknown URLs.
Ari Weinstein notes that user-facing design also plays a critical role in demystifying the technology. By visualizing the agent's cursor movement on the screen with playful animations, users can observe the machine working in real time without feeling alienated. Furthermore, baseline prompts require the agent to ask permission before touching any new desktop application, creating transparent operational boundaries that allow both consumers and enterprise workers to build gradual trust.
- **Deterministic sandboxing**: Administrators set strict rules defining which specific enterprise applications, local directories, and web domains an agent is permitted to touch.
- **Configurable intervention triggers**: High-stakes operations, such as file uploads, downloads, or unapproved domain visits, can be hard-coded to require mandatory human confirmation.
- **Visual trust mechanics**: Real-time cursor tracking and interactive animations maintain full visibility over agent actions, reducing the "black box" sensation of automated computer use.
`20:00` Enterprise Use Cases: Automating Tedious Workflows and Legacy Systems
The conversation opens on the psychology of user trust and interface design when watching models operate computers. The hosts remark on visual feedback elements—such as the distinctive Codex cursor—which make watching an agent control a machine reassuring rather than alarming: “The Codex cursor is so cute. I love it. It's like such a, I know it's a small detail, but like watching it use the computer gives you like experience point. That's worth, that's definitely worth investing on.”
With models becoming significantly more capable and cheap enough to deploy at scale, attention turns to enterprise automation. James Sun outlines two major categories, beginning with what he terms the "boring" category—which he immediately reframes, agreeing with the hosts that “boring as opportunity.” This encompasses legacy systems of record that dominate enterprise operations:
```mermaid
flowchart TD
accTitle: Manual vs Automated Enterprise Procurement Workflow
accDescr: Diagram illustrating how computer-using agents replace tedious human spreadsheet handoffs between departments.
subgraph Manual["Legacy Manual Workflow"]
A["Team fills 1,000-row spreadsheet"] --> B["Ops re-enters into internal ERP"]
B --> C["Procurement parses output lines"]
C --> D["Sales/Procurement contacts vendors"]
end
subgraph Automated["Computer Use Workflow"]
E["Autonomous Computer-Using Agent"] -.->|"Direct UI automation & reconciliation"| D
end
```
- **Procurement and ERPs:** James illustrates how a company ordering lab equipment typically relies on a manual chain: one team fills out a 1,000-row spreadsheet; an operations team manually inputs those lines into internal procurement software; and the procurement team then parses the finalized lines to contact external vendors. Computer-using agents can automate this entire handoff across non-integrated tools.
- **Finance and Reconciliation:** Month-end financial closes require pulling data across disparate internal expense and balance ledgers. Because many legacy accounting tools lack APIs for direct export, computer use enables agents to read the screens, match entries across ledgers, reconcile balances, and flag suspicious anomalies for human investigation.
- **Sales Prospecting and CRM:** Sales organizations juggle disjointed tools for meeting transcripts, contact databases, and outreach pipelines. Agents can autonomously prospect, extract relevant details from customer records, and populate CRMs without custom integration plumbing.
- **Market Research:** James shares a personal anecdote about building video annotation software for badminton, a sport he plays often. Wanting to benchmark existing tools for tennis, pickleball, and squash, he had computer-using agents independently sign up for competitor apps, test features, capture screenshots, and synthesize design feedback to incorporate into his own product.
- **Visual Engineering and Design:** Beyond back-office forms, multimodal improvements allow models to handle visual-spatial domains like circuit design, architectural blueprints, hardware engineering, and game design.
`25:00` Consumer Utility, Legacy Software, and the Future of UI Craftsmanship
Ari Weinstein shifts the discussion toward consumer applications, breaking them down into drudgery reduction, time-unlocking enablement, and entirely new interaction paradigms. On the drudgery side, agents handle DMV paperwork and batch-unsubscribe from junk email. In the second bucket, they allow users to execute projects that would otherwise be abandoned due to sheer time constraints:
> “I think kind of similarly on the consumer side, there's a lot of things where it's sort of automating drudgery or just doing things you don't want to do.”
Ari explains that he personally uses agents to manage his financial spreadsheets and meal plans inside Apple Numbers—a software choice that elicits amusement from the hosts, though Ari defends it: “I use Apple Numbers, which is like a obscure spreadsheet program, but the model still knocks it out. I don't think I've ever heard someone use Apple Numbers. It's a surprisingly great spreadsheet software.” He also points to a personal trainer friend who uses agent workflows to design tailored fitness programs for every client. Looking further out, Ari points to voice-driven operating system interaction (previewed in Astra demos) where users simply talk to their computers, altering the fundamental form factor of software.
This raises a debate on software evolution: will agents simply serve as a UI wrapper keeping 30-year-old legacy ERPs alive indefinitely, or will they enable a wave of AI-native software companies? Ari notes that both realities will coexist:
> “It is such an interesting moment where simultaneously the cost and complexity of creating new software is so much lower. So you can't imagine software changing so much, but also there exists so much legacy software in the world that computer use is so well-suited to interact with. So I expect both of those things to continue for a long time.”
Ari highlights protocols like WebMCP (Model Context Protocol applied to web interfaces) as a sign that the universal availability of computer-using agents will actually force existing software vendors to optimize their user interfaces for agent interactions by default.
James Sun concludes with an impassioned defense of human-centric design, insisting that the future of computing will not merely be an invisible, faceless web of agents executing API calls behind closed doors:
> “And I don't know, like for me, if we go, if the internet becomes just this like faceless, you know, thing that is just agents talking to each other and people are not using anything anymore, I would be very sad.”
To demonstrate the emerging era of hyper-personalized software, James shares a story about his wife, who had taken up the five-in-a-row pebble board game Omok (Gomoku):
- Frustrated by losing to online friends, she needed practice, so James quickly hand-crafted a bespoke tactical trainer designed around her exact learning habits and preferred gambits.
- While an agent can summarize end-of-game mistakes into a textual debrief, the actual experience of playing and interacting remains an intrinsically human activity.
- Rather than eliminating software front-ends, the drastically reduced cost of software creation will allow non-engineers to produce niche, artisanal applications tailored to individual human tastes, ensuring the user interface remains vital.
`30:00` Rethinking Human-AI Interfaces and the Shared Intelligence Layer
Ari Weinstein begins by exploring how human beings are fundamentally “hardwired for direct manipulation” and naturally desire to move and interact with their own hands. He reflects on how legacy software was unavoidably "one size fits all" because it had to serve millions, tens of millions, or even billions of users. AI shifts this paradigm entirely toward hyper-personalized software designed for as few as a hundred people, making it feel deeply personal and unique. The hosts sketch out a two-bucket mental model for human-software interaction:
- **Consumer software:** Centered on intrinsic joy, learning, and time well spent rather than pure utility.
- **B2B / Enterprise software:** Centered on goal-setting, execution, and oversight. Users want the agent to handle tedious manual work (such as calculating payment schedules, 30-day terms, and invoice discounts), while the user monitors the logic via an audit log and retains final control through a dedicated interface.
Ari underscores that UI still matters deeply even as agents automate workflows, noting that business software shouldn't have to be unpleasant: “Why should we settle for shitty software?” He envisions a category of modern applications that combine traditional interfaces with background agents that use computer use to drive clunky legacy platforms under the hood. James Sun expands on this with the concept of an internal "shared intelligence layer." If every individual website builds its own isolated agent that cannot communicate with the user's personal agent, the software ecosystem will end up painfully fragmented. The winning paradigm will be agents that can seamlessly plug into other software, share context across applications, and act as a unified bridge.
```mermaid
flowchart TD
accTitle: Shared Intelligence Layer Architecture
accDescr: Diagram showing how a user agent sits between modern user interfaces and disparate legacy software tools via a shared intelligence layer.
`32:51` Startup Moats: Domain Expertise and Vertical Integration
Fabrizio Serafini turns the conversation to founders: if an entrepreneur is launching a startup today to solve enterprise workflows with computer use, how should they design the human-agent collaboration, and what moats remain when foundation model labs move so quickly? Ari explains that the architecture depends heavily on the deployment modality:
- **Small internal teams:** Focus on augmenting individual team members locally with tools like ChatGPT so they can navigate existing company software more efficiently.
- **Enterprise-scale background platforms:** Spin up headless virtual machines in the cloud running computer use autonomously. In this setup, the core product challenge is calibration: determining when to loop the human in, summarizing activity without spamming notifications that get ignored, and highlighting both exceptions and successes cleanly.
Addressing the question of defensibility against frontier labs, James Sun emphasizes that both he and Ari are former startup founders and remain extraordinarily bullish on early-stage companies. Even though OpenAI has scaled to thousands of employees, internal teams are stretched thin across fundamental research and core platforms, leaving massive white space in the market:
> “And so if you have a problem that you really deeply understand, you have industry expertise, you understand how regulatory works, the go-to-market motion, how to service those customers, it is still, I think, a very green field out there.” — James Sun
James highlights that within the current landscape, “speed and pain is kind of the moat that exists today.” While Silicon Valley often assumes frontier labs will instantly build and deploy everything end-to-end, the actual diffusion of AI into traditional vertical industries is far slower. The barrier for an average small-to-medium business or enterprise is not the raw existence of an API, but understanding capabilities, connecting disparate tools into a unified workflow, deploying the software, and ongoing customer servicing.
James illustrates this through a real-world vertical case study of a startup using computer use for restaurant group operations:
1. **Vision-based inventory:** Cameras capture images of the back-room storage.
2. **Predictive demand modeling:** Computer vision identifies low stock and cross-references it with foot-traffic projections based on historical holiday and calendar trends.
3. **Automated procurement:** The agent launches a browser, navigates to Shopee or dedicated restaurant supply portals, and places grocery orders for the next morning.
4. **Labor scheduling:** The agent navigates into the restaurant's legacy ERP to adjust shift schedules and increase floor staff for predicted traffic spikes.
`37:25` The Frontier: Superhuman Speed and Unified Consumer Experiences
Looking toward the near-term frontier, Ari and James outline what is coming next for computer-using agents. Ari highlights three core priorities:
1. **Superhuman execution speed:** Accelerating model decision-making and browser execution loops so agents navigate software far faster than human operators.
2. **Multimodal, fluid collaboration:** Moving beyond purely asynchronous background batch tasks toward real-time, interactive collaboration between the human and the agent.
3. **Accessibility and cost:** Making models progressively cheaper, easier to orchestrate, and accessible across arbitrary operating environments.
James focuses on tackling the UX fragmentation currently plaguing computer-use implementations. Today, users face a confusing patchwork of isolated states:
- A local browser extension (e.g., Chrome) that shares the user's native password manager and local cookies.
- An in-app desktop browser running within ChatGPT with a separate state.
- Remote cloud virtual machines (such as OpenAI's sandbox environments) with distinct sessions and credentials.
When tabs, authentication tokens, and cookies do not synchronize across these environments, normal users get baffled. James points out the central irony of the technology: “It's kind of like an oxymoron because I think computer use is actually the most easy to understand AI product because it's an AI using a computer. But then because of the complexities of the different states you have to manage and the different places you're using it, the implementation details sometimes seep through and then it becomes kind of hard to grok.” Transforming computer use from a specialized developer tool used by tip-of-the-spear enterprises into a seamless, coherent, consumer-grade product represents the major design and engineering push for the coming quarters.
`40:00` Shifting from User Adaptation to Agent Proactivity
A fundamental friction with current agentic software is the cognitive load placed on the user. Today, people still have to deliberately remind themselves to trigger an agent, decide how to structure their instructions, and overcome years of ingrained muscle memory regarding how digital work is performed. As the speakers emphasize, software adoption hinges on intuitive user experience and seamless controls, especially when a human must actively initiate every workflow. The goal is to move past the phase where humans must constantly accommodate software quirks and instead enter an era where agents dynamically anticipate needs. As Ari Weinstein explains: “I'm really excited about a world where the agent can sort of adapt to you instead of you adapting to it.”
This shift toward proactivity promises to fundamentally lower the barrier to entry. Instead of requiring users to master complex prompt engineering or figure out the exact boundaries of what an agent can and cannot execute, more proactive agents will step in contextually to assist with problem-solving. Crucially, this evolution does not remove the human from the driver's seat; users will continue to establish the overarching objectives, set boundary conditions, and steer high-level intent while the agent handles execution behind the scenes.
- **Current user friction**: Users currently bear the cognitive overhead of remembering to invoke the agent and actively rewiring their standard operating habits.
- **Goal steering vs. execution**: Greater agent proactivity allows users to remain focused on defining high-level goals without needing to micromanage step-by-step digital tasks.
---
`41:15` The Scaling Moment: From Atlas to Ubiquitous Cloud-Based Agents
Reflecting on the evolution of computer-using agents over the prior six to nine months, Ari Weinstein and James Sun outline a dramatic transition inside OpenAI. Earlier in the year, breakthroughs from the research team suddenly unlocked the model capabilities required for agents to perform sophisticated computer tasks. Internal teams spent months engineering the product harness and practical interfaces around those models. James Sun recounts joining OpenAI in January to work on Atlas—joking, “I love Atlas, RIP Atlas”—and notes that Atlas struggled because users largely treated it as a conventional web browser rather than an agentic platform. The turning point arrived when the team took browser and computer-use capabilities and embedded them directly into existing products where users were already engaged in agentic workflows. As James Sun observes: “And over the last few months, because the model capabilities have gotten better, we've now incorporated browser and browser use into kind of all of our existing products where there was already agentic usage.”
```mermaid
flowchart TD
accTitle: Evolution of Computer-Using Agents at OpenAI
accDescr: Shows the progression from early standalone browser agents like Atlas to integrated cloud-driven agent experiences across consumer mobile and desktop.
subgraph EarlyPhase["Early Phase"]
A["Standalone Agent Browser<br/>(Atlas)"] -->|"Users treat it like<br/>a normal browser"| B["Limited Agent Adoption"]
end
subgraph CapabilityShift["Model Breakthrough"]
C["Research Team Advances<br/>in Computer Use"] --> D["Embed Browser Tooling<br/>into Existing Products"]
end
subgraph CurrentScaling["Current Inflection Point"]
D --> E["Explosive Growth<br/>('YC-level week over week')"]
E --> F["Shift to Cloud Execution"]
end
subgraph NextFrontier["Scale to Billions"]
F --> G["Headless Cloud Computer<br/>Powering Mobile Consumers"]
F --> H["Enterprise Legacy ERP &<br/>Desktop Automation"]
end
B -.-> C
```
This integration unlocked explosive, “YC level of growth week over week.” However, both Sun and Weinstein stress that the industry is still in the earliest innings of adoption. The current paradigm remains heavily tethered to desktop computing, which represents an inherently power-user surface. The vast majority of global consumer activity happens on smartphones. The next massive inflection point centers on cloud-hosted execution: provisioning a powerful, headless cloud computer for every user via chat interfaces on their phones, abstracting away the underlying operating system entirely so ordinary consumers can reap the benefits of desktop-grade software automation without ever touching a desktop machine. Looking at the dual expansion into consumer mobile and enterprise environments, Ari Weinstein summarizes the inflection point: “I think we're at the scaling moment of computer use, both for consumer and enterprise at the same time.”
- **The Atlas experiment**: Early efforts like Atlas demonstrated that packaging an agent as a dedicated browser failed to gain traction because users treated it like standard browsing software rather than an autonomous helper.
- **Distribution via existing surfaces**: Embedding computer-using tools directly into existing agent products unlocked viral, week-over-week compounding growth.
- **The desktop vs. mobile divide**: While tech power users rely heavily on desktops, reaching billions of mainstream consumers requires running headless, agentic computers in the cloud controlled via mobile chat interfaces.
- **Enterprise and consumer convergence**: Improving reliability, safety controls, and coherent multi-step execution are making computer-using agents practical across legacy enterprise backends and mass-market consumer applications simultaneously.
## Notable quotes
> `08:32` We've gotten computer use now to a place where it's faster than the average human at using a computer. — Ari Weinstein
> `41:15` I think we're at the scaling moment of computer use, both for consumer and enterprise at the same time. — Ari Weinstein
> `40:00` I'm really excited about a world where the agent can sort of adapt to you instead of you adapting to it. — Ari Weinstein
## Mentioned
OpenAI, Astra, Ari Weinstein, James Sun, Seema Amble, Fabrizio Serafini, Andreessen Horowitz (a16z), Microsoft Paint, Fallout, Dot, Slack, Sentry, Codex, Guardian, WebMCP, Apple Numbers, Shopee, Atlas, ChatGPT, Google Chrome
## Video description
AI agents are approaching a point where they can use computers faster than expert humans, turning the user interface itself into a universal way for AI to interact with software. OpenAI’s Ari Weinstein and James Sun argue that computer use is now entering its scaling moment, as better models, faster execution, and stronger safety controls make agents practical for more consumer and enterprise work.
Ari and James join a16z’s Seema Amble and Fabrizio Serafini to explain how computer-using agents are already navigating legacy ERPs, reconciling financial data, handling procurement, and operating software without APIs or custom integrations. They also discuss why the harness around the model can matter as much as model intelligence, how enterprises can set deterministic guardrails around agent behavior, and why computer use could simultaneously extend the life of legacy software and accelerate the arrival of new AI-native applications.
Looking ahead, they make the case for a more proactive and fluid relationship with computers, where agents work in the background, collaborate with users in real time, and increasingly adapt to us rather than requiring us to learn how to use them.
OpenAI's Ari Weinstein and James Sun argue that computer-using AI agents have surpassed average human speed and are approaching superhuman execution by directly interacting with standard graphical interfaces rather than requiring custom APIs. As reliability and speed improve, adoption hinges on enterprise deterministic guardrails, multi-environment synchronization, and shifting from user-prompted tasks to proactive assistance.
Universal Interfaces Over Custom Integrations (14:04)
Computer-using models navigate existing front-end user interfaces identically to human operators, bypassing the need for bespoke APIs, Model Context Protocol (MCP) servers, or third-party connectors. Weinstein notes that this universality unlocks legacy enterprise platforms, such as 15-to-20-year-old ERP and accounting software, that lack modern programmatic endpoints. By reading screens and operating UI elements directly, agents can automate complex manual cross-system tasks—including 1,000-row procurement spreadsheets and month-end financial reconciliations—without requiring enterprises to rewrite underlying systems.
While automation succeeds inside enterprise boundaries, public web browsing introduces conflicting incentives. Ad-supported websites and publishers rely on human pageviews to monetize traffic, and automated scraping or headless navigation challenges those business models. In response, emerging standards such as WebMCP seek to support collaborative browsing, allowing human users to handle visual discovery or checkout while delegating form filling and data extraction to the agent.
Speed Milestones and Oversight Controls (8:32)
Weinstein states that computer-use agents now operate faster than the average human user and are nearing superhuman speeds where they outperform expert users. While latency is less critical for asynchronous background workloads, real-time supervision becomes frustrating if an agent operates slower than manual input. However, superhuman execution speeds make real-time visual tracking impractical, creating an auditability dilemma for enterprises that must monitor autonomous actions.
To balance autonomy with risk management, Sun outlines deterministic security controls alongside Guardian, a dedicated oversight model that inspects every discrete step an agent proposes to verify safety and alignment with original user intent. Beyond model alignment, enterprise administrators rely on deterministic sandboxing—such as domain whitelists and mandatory human sign-off triggers for file downloads, uploads, or untrusted URLs—to maintain operational boundaries.
Startup Defensibility in Vertical Markets (32:51)
Despite rapid advancements from foundation model labs, Weinstein and Sun contend that large research organizations remain focused on core models and general infrastructure, leaving open market space for vertical startups. Defensibility relies on deep industry knowledge, regulatory compliance, and distribution rather than proprietary model weights. Sun points out that the operational friction for small and medium enterprises stems from deployment logistics, tool integration, and ongoing service rather than the raw availability of an API.
Illustrating this dynamic, Sun cites a vertical restaurant management startup that coordinates vision-based inventory from storage cameras, cross-references historical foot-traffic trends, automatically places grocery replenishment orders through web portals, and logs into legacy ERPs to adjust shift schedules. Early-stage companies can defend their models by stitching domain-specific edge cases into end-to-end workflows that generalized models do not natively solve out of the box.
Fragmented States and Proactive Cloud Agents (37:25)
The user experience for computer use remains fragmented across disparate execution environments, including local browser extensions, in-app desktop clients, and remote cloud sandboxes that do not share authentication tokens, session cookies, or tabs. Sun notes this fragmentation creates cognitive overhead because users must navigate conflicting states. Additionally, users still carry the burden of remembering to invoke the agent, overcoming established manual habits through explicit prompting.
Looking forward, the architecture is pivoting toward proactive execution and cloud-hosted virtual machines. Reflecting on earlier experiments like Atlas—which struggled because users treated it as a conventional browser—the team found substantial adoption by embedding agentic capabilities directly into existing workflows. Weinstein and Sun observe that reaching mainstream users will require provisioning headless cloud computers managed through mobile chat interfaces, moving beyond desktop power-user surfaces and allowing agents to anticipate context autonomously.
OpenAI views computer-using agents as entering a joint enterprise and consumer scaling phase, yet broad adoption remains constrained by session fragmentation across local and cloud environments, ad-monetization conflicts on the open web, and the UX friction of requiring manual user prompting instead of autonomous anticipation.
## Background
本期内容由 a16z 的 Seema Amble 和 Fabrizio Serafini 联合主持发布于播客平台,于 2026 年 10 月 26 日上线。节目邀请了来自 OpenAI 的 Ari Weinstein 和 James Sun,深度探讨了 AI 代理(Agent)在“计算机使用”(Computer Use)能力上的跨越式进化,以及它如何通过图形界面直接驱动软件、重塑消费端与企业端的工作流与人机交互形态。
## TL;DR
对话重点探讨了计算机使用(Computer Use)技术如何将图形界面(GUI)变为 AI 与软件交互的通用接口,模型操作速度不仅超越了普通人类,更在逼近专家水准。在企业端,具备高抗注入安全对齐与确定性沙箱机制的代理,能够在无需任何现代 API 的情况下自动化操作使用数十年的老旧 ERP、采购与财务对账流程;在消费端,内部项目 Dots 则通过云端虚拟电脑展示了主动式协同与复杂排障潜力。嘉宾们强调,UI 不会走向消亡,而是会从千人一面的工具演化为高度定制的交互界面,伴随云端虚拟机的下沉,这种能力终将走出桌面极客圈层,让移动端普通用户也能享受通用算力的代劳体验。
## Atmosphere & style
整场对谈充满务实的技术前瞻与极客视角的兴奋感,两位一线研发核心不仅分享了硬核的工程见解,更带着对真实工作流细节的敏锐洞察。对话氛围轻快而坦率,既有幽默自嘲“安息吧 Atlas 项目”和调侃“老旧系统极其难用”的松弛感,又有关于“软件手工艺温度”的真情流露。听众能真切感受到前沿模型从实验室突破到实际产品落地时的指数级脉动,以及一种人机交互历史正在迎来颠覆性反转的临场紧迫感。
## Bulletin
- `08:35` OpenAI 的新一代模型 Astra 在计算机使用(Computer Use)领域取得质的飞跃,其操作电脑的综合速度已超越普通人类,并正逼近熟悉快捷键的专家级水准。
- `10:00` 企业级应用迎来自主性与安全的平衡,OpenAI 引入 Guardian 审查模型与确定性沙箱,允许管理员对数据上传下载及域名访问设置硬性安全兜底策略。
- `20:00` 传统企业中采购管理与财务对账等缺乏现代 API/MCP 的 15-20 年老旧 ERP 系统,正成为 AI Agent 替代人工琐碎录入、“枯燥即机遇”的核心落地沃土。
- `43:08` 计算范式正走向移动端与云端解耦,通过为手机用户分配云端虚拟桌面并抹平 Cookie 与状态差异,计算机使用技术正迎来面向大众的规模化爆发拐点(scaling moment)。
## Key takeaways
- `00:00` Astra 模型通过减少思考 Token 消耗和将可靠性从 97% 提升至 99%,跨越了用户敢于放手托付关键自动化任务的心理阈值。
- `03:07` Astra 系统卡显示其在抵御 Prompt 注入攻击及防范非预期误操作方面大幅增强,为企业采购、客服等敏感业务落地筑牢安全底座。
- `05:00` OpenAI 内部项目 Dots 展示了云端虚拟电脑形态,Agent 能够主动拦截收件箱未同步的日历邀请,并打通 Sentry 日志抓取与 Codex 分析排错的复杂闭环。
- `08:35` 计算机使用速度是产品的核心生命线,超越人类操作速度将彻底反转人机交互模式,让人类默认授权 Agent 代劳而仅在异常时接管。
- `10:00` 企业端部署 Guardian 独立模型实时审视主 Agent 的每一个原子点击,兼顾消费端的全自动执行与企业端人机协同(HITL)审批自由度。
- `12:35` 广告模式驱动的出版商因流量未计入有效曝光而面临冲击,OpenAI 推动 WebMCP 标准以保留人类浏览 UI 乐趣并交由 Agent 处理比价结算。
- `14:48` Computer Use 凭借注视屏幕、敲击键盘的拟人化交互具备绝对的通用性,无需依赖专有 API 或连接器即可无死角驱动任何现有软件。
- `17:41` 针对企业的顾虑,系统通过限定白名单域名的确定性沙箱与拟人化平滑光标轨迹动效,将黑盒执行转变为可审计的人机协作流。
- `20:00` 采购管理填表和财务月末多账本对账等缺乏 API 的“枯燥记录系统”,成为计算机使用 Agent 降本增效最立竿见影的应用场景。
- `25:00` 未来并非没有 UI,精美的图形界面承载着人类学习与享受交互的手工艺温度,智能体将作为后台支持与历史老旧 ERP 的操作外壳并存。
- `30:00` AI 时代软件不再千人一面,未来将诞生针对极少数人量身定制的优雅 UI,并通过跨软件的“共享智能层”统一协同逻辑。
- `33:15` 大模型实验室无法垄断一切,初创企业的真正护城河在于下沉到餐饮后厨等垂直行业的痛点深耕,并以极快的速度实现端到端闭环。
- `37:37` 产品体验亟需解决多端割裂痛点,抹平云端虚拟电脑、本地客户端与扩展之间的状态与 Cookie 差异是实现消费级普及的前提。
- `40:00` 人机交互的核心进化方向是“由 Agent 主动适应人类”,消除用户刻意改变习惯的认知摩擦,人类只需专注于高阶意图与方向把控。
- `41:40` 单纯在浏览器内嵌 Agent 的 Atlas 路线未能改变用户习惯,唯有将底层的计算机使用能力深度赋能至全线 Agent 产品,才引发了指数级增长。
- `43:08` 桌面端只是极客的专属,通过云端虚拟桌面将超级计算机操作能力无缝打包递送给全球移动手机用户,是推动技术普惠的核心转折点。
## Detailed walkthrough
### `00:00` 开篇导言与新一代模型的技术跨越
在节目开场,来自 a16z 的 Seema Amble 和 Fabrizio Serafini 引入了本期主题:计算机使用代理(computer-using agents)正在经历实质性的飞跃。随着大模型能力的提升与运行成本的骤降,AI 已经可以直接通过图形界面(GUI)像人类一样操作网页与企业软件,而无需依赖专有 API 或开发者费力搭建的模型上下文协议(MCP)服务。OpenAI 的 Ari Weinstein 和 James Sun 指出,现在的代理操作电脑的速度已经超越了普通人类,并且正在逼近超越“专家级人类操作员”的超人(superhuman)水准。从底层逻辑来看,计算机使用技术正在成为 AI 与所有既有软件交互的通用接口。
Ari Weinstein 回顾了技术迭代中的细微而关键的突破。他提到,即使在早期模型已经表现优异的背景下,新一代模型 Astra 依然在边缘场景中带来了质的飞跃:一方面,它在处理相同任务时所需的思考 Token(thinking tokens)更少,从而让整体执行速度变得更快;另一方面,它在创意型任务中的表现尤为惊艳,比如在官方发布演示中,模型能够一边听取语音指令,一边在 Microsoft Paint(微软画图)中精准作画。最核心的进化在于其可靠性边界的推进——看似微小的百分比跃升,却直接重塑了使用者的信任感。
> “It's sort of the kind of thing where there's a little difference that is hard to perceive, but really important between something being 99% reliable and 97% reliable.” —— Ari Weinstein
- **思考效率提升**:Astra 消耗更少的思考 Token 即可完成原本繁复的 GUI 操作链路。
- **可靠性跃迁**:从 97% 到 99% 的可靠性改善,跨越了用户敢不敢把关键任务放手交给 AI 的临界阈值。
- **多模态创意控制**:在实时交互下驱动画图等非结构化软件的能力大幅成熟。
---
### `03:07` C端与B端分野:对齐安全与遗留系统的自动化破局
James Sun 进一步补充了模型在安全与对齐(alignment)维度的底层优势。根据 Astra 的系统卡(system card),该模型在抵御 Prompt 注入攻击(prompt injection)以及防止发生任何非预期误操作方面有了断层级的提升。在企业端,尤其是面对采购、供应商对接以及客户服务等极为敏感的核心工作流时,极高的安全性与可审计性(auditability)成了大客户敢于落地代理的基石。在谈及模型的游戏基准表现时,James 甚至幽默地分享了一个内部测试案例:Astra 在打电子游戏方面完胜之前的版本,甚至能在 30 小时内通关《辐射》(Fallout)。
两名嘉宾在业务分工上也形成了互补:Ari 更聚焦于探索 C 端(消费者)体验的前沿极限,而 James 则深耕 B 端(企业级)解决方案。James 强调,企业内部存在大量使用了 15 至 20 年的遗留企业级软件(Legacy ERP 等),这些系统根本没有现代的 API 或 MCP 工具支持,UI 界面陈旧且反人类,新员工上手极难。AI 代理具备的视觉驱动与直接操作电脑能力,让企业可以通过编写技能(skills)教会模型如何精准操作这些十年前的系统,使企业无须大动干戈重构系统就能实现端到端自动化。
> “Inside enterprises, there's lots of legacy software that doesn't have any MCP tools. They are software that's been used for 15, 20 years. And so a lot of times it's actually kind of hard to use for a normal person.” —— James Sun
```mermaid
flowchart TD
accTitle: AI 代理跨场景应用架构
accDescr: 展示 AI 代理如何分别在消费端与企业端驱动不同任务并连接底层模型
subgraph Consumer["消费端场景 (探索体验前沿)"]
C1["云端独立电脑"]
C2["主动式个人助理 (Dots)"]
C3["个人日常事务 (预约/采购)"]
end
subgraph ModelLayer["Astra 核心模型底座"]
M1["更少的思考 Token 消耗"]
M2["高防 Prompt 注入能力"]
M3["超高可靠性 (99%+)"]
end
subgraph Enterprise["企业级场景 (打通遗留价值)"]
E1["15-20年历史的遗留系统 (无 API/MCP)"]
E2["复杂工作流 (采购 / 报销 / 供应商)"]
E3["日志分析与研发排错 (Sentry/Slack)"]
end
ModelLayer --> Consumer
ModelLayer --> Enterprise
```
---
### `05:00` Dots 代理实战:主动式协同与跨本地/云端的运维闭环
在谈到消费级代理的具体产品形态时,Ari 描绘了 OpenAI 内部项目 Dots 的愿景:为每一个 Dot 分配一台运行在云端的独立虚拟电脑,配备完整的网络浏览器。用户不再需要把时间浪费在订剪发预约、网购比价等琐碎事务上,只要给出一个高阶意图,Dot 就会在云端默默完成任务。
James 结合自己的日常高阶工作流,深度解析了 Dots 与“传统自动化脚本”的本质差异:
1. **日历漏洞的主动式拦截**:公司内部邮件系统在收到外部日历邀请时经常无法自动同步到 Google 日历,导致他屡屡错过外部会议。Dot 表现出极高的主动性(proactive),会在收件箱里巡检出未同步的邀请,并主动向 James 提示:“收件箱里有个邀请没有出现在日历上,需要我登录你的 Gmail 帮你接受它并同步到日程吗?”
2. **长尾与不规则排错闭环**:James 之前写过定时运行的代码和自动化任务来抓取内部 Slack 频道的关键反馈,但由于规则过于生硬,产生了大量噪音并最终被他麻木忽略。而 Dot 允许设定高维度的模糊目标——例如“只要我下属汇报线里的成员发言,或者有人提出了关于产品的关键批评,就立刻高亮标注”。
3. **驱动本地与云端双环境排障**:当用户提交附带 Sentry 日志链接的 Bug 时,Dot 可以同时操控云端虚拟机与本地浏览器,自动登录 Sentry 抓取对应的报错堆栈日志,将其转交至内部分析工具 Codex 中剖析成因,最后生成结构化反馈发回给 James,彻底消除了“看反馈 -> 开 Sentry -> 下载日志 -> 喂给模型 -> 分析排查”这一整条繁重的人工循环。
- **动态适应非固定工作流**:打破传统 RPA 只能处理固定输入模版的弊端,代理可以从容应对非结构化输入。
- **混合运行环境**:单个代理实例既能掌控本地计算机的环境上下文,又能跨越到云端沙盒中并发执行脏活累活。
---
### `08:35` 速度临界点:从“慢速旁观”到超越专家人类
在讨论可靠性、运行速度与 Token 消耗效率之间的平衡时,Ari 直言,速度一直被低估,它实际上是决定产品形态的核心生命线。尽管计算机使用在理论上适合放在后台运行,哪怕慢一点也无妨,但在实际使用中却存在两大心理痛点:首先,某些关键任务需要前置完成,用户必须原地干等;其次,如果代理在屏幕上点击、加载的过程过于缓慢,用户往往会不可抑制地产生一种“这速度我还不如自己去点,早就弄完了”的挫败心理。
Ari 宣布,当前 OpenAI 的模型在使用电脑的综合速度上,已经正式超越了普通人类(average human)的平均操作速度,而且正在迅速逼近超越精通各种快捷键、熟悉所有系统的“专家级计算机使用者”(expert human)。他预言,一旦迈过这个超人临界点,人机交互范式将发生颠覆性的质变——除非用户出于某种极特殊的个人偏好想亲手操作,否则在默认状态下,人类都会选择让代理全权代劳。
> “We've gotten computer use now to a place where it's faster than the average human at using a computer. And I think we're getting really close to a place where it is superhuman, meaning it is faster than an expert computer user like probably one of us at this table.” —— Ari Weinstein
- **心理耐受度与产品体验**:操作延迟一旦过长,用户就会随时收回控制权;超越人类速度是建立全面代理信任的必经之路。
- **默认交互规则反转**:人机交互的历史将从“人类操作计算机、AI 提供辅助”,彻底转向“AI 操作计算机、人类仅在异常时接管”。
### `10:00` 自主性、审计权与企业安全防护机制
随着模型在不同质量与价格梯度上的演进,用户面对特定任务时有了更丰富的选择空间,更便宜的小模型在计算机使用(Computer Use)能力上也正在飞速提升。然而,当模型执行速度加快、达到人类无法逐帧监视其行为的超人(superhuman)水平时,控制权、安全感与可审计性就成了企业最为核心的关切。过去模型速度慢时,人类尚且能盯着屏幕看它操作,但这种做法效率极其低下;如今,企业迫切需要一种既能放手让 Agent 自主执行、又具备安全兜底的机制。
```mermaid
flowchart TD
accTitle: Computer Use Agent Enterprise Governance Flow
accDescr: 企业端对计算机使用 Agent 的双层管控机制:Guardian 模型审查与确定性策略沙箱
subgraph User["用户层 / 交互界面"]
ActionReq["任务请求 / 意图输入"]
end
subgraph Engine["执行核心"]
CU["Computer Use Agent"]
end
subgraph Security["双层安全保障"]
direction TB
Guardian["智能审查: Guardian 模型<br/>(逐项比对操作意图与安全性)"]
Sandbox["确定性策略沙箱<br/>(应用黑白名单 / 上传下载拦截)"]
end
subgraph Decision["放行决策"]
AutoPass["自动审批放行"]
HITL["人机协同审批 (Human-in-the-Loop)"]
end
ActionReq --> CU
CU --> Guardian
Guardian --> Sandbox
Sandbox -->|"普通安全操作"| AutoPass
Sandbox -->|"敏感操作 / 新建站点 / 数据外发"| HITL
```
为了解决这一矛盾,OpenAI 在其相关架构(如 Astra)中推出了整套企业控制套件。系统引入了一个名为 Guardian 的独立智能模型,专门实时审视 Computer Use Agent 的每一个原子操作,严密核验该操作是否安全、是否符合用户的最初意图。消费者可能倾向于全自动执行,不希望被任何审批打扰;但企业端则拥有完整的权限旋钮,可自由决定哪些动作允许自动放行,哪些必须触发人机协同(Human-in-the-Loop)。
> “We have this really awesome system called Guardian, I think auto-approve in the app, that is a really smart model looking at every single action that the computer use agent is taking to decide if it's safe, if it's aligned to their original intent.” —— James Sun
- **Guardian 模型机制**:部署在端内的轻量且高智能监控模型,对主 Agent 的每一步操作(点击、跳转、数据输入)进行实时语义审查。
- **人机协同配置自由度**:企业管理员可在后台精细化定义干预阈值,在“全自主执行”与“每步人工审批”之间灵活调节。
---
### `12:35` 软件生态的分化:广告商业模式的冲击与 WebMCP 协同标准
当使用计算机的 Agent 开始跨越内部系统、广泛穿梭于外部开放网络时,软件生态与网站运营方出现了明显的分化阵营。在企业内部审批过的软件(如 ERP、内部工作流工具)中,引入 Agent 毫无阻力,因为企业本就渴望消除员工繁琐重复的手工录入;但在公网环境中,商业利益的冲突瞬间显现。以数字广告和流量变现为核心的出版商和内容网站陷入了困境——Agent 的页面访问和交互通常不会被广告计费系统计为有效曝光,直接动摇了其营收基石。
与此相对,另一派企业则选择主动拥抱 Agent,通过新兴协议探索人机共存的新范式。OpenAI 在内置浏览器中率先支持了 WebMCP 标准,旨在让用户与 Agent 在同一个界面中协同交互,而非完全将网页剥离成冷冰冰的后端 API。这种方案保留了人类浏览互联网的乐趣(例如挑选心仪的度假酒店、对比商品外观),同时把烦琐的流程(如抓取比价、填写配送信息、执行支付结算)交还给 Agent 处理。
> “And so WebMCP is kind of an interesting way where your interface with the website is still the site itself versus an API, but then the person is kind of using it together.” —— James Sun
- **商业模式冲突**:纯广告驱动型网站无法从 Agent 的自动化访问中获得有效 ad impression,OpenAI 的商务合作团队正与相关方共同探索新的分成与衡量方案。
- **WebMCP 标准优势**:无需各站点单独重构 API,保持人类友好型 UI 的同时赋予 Agent 结构化协作通道,实现“人类负责探索与决策、Agent 负责苦力活”的双轨体验。
---
### `14:48` 通用交互界面的质变:从产品需求到直接代劳
对于“什么样的任务适合移交给 Agent”这一边界问题,团队的认知已经发生了根本性转变:如今的通用计算机操作模型在能力上已基本能够胜任人类在电脑前所能完成的绝大多数工作。James Sun 甚至强迫自己建立一种全新的肌肉记忆——每次面对电脑任务时,首要反应不再是亲自动手,而是直接把任务甩给 Agent。即便用户的初始指令存在模糊或空缺,最新的自适应输入(Flexible Input)功能也能在需要时主动向用户追问细节;如果用户没有及时回应,Agent 还会自动推测并调取必要的上下文继续推进。
Ari Weinstein 强调,计算机使用(Computer Use)最颠覆性的特质在于其绝对的“通用性(Universality)”。以往任何技术落地,都依赖开发者编写专用连接器、适配 MCP 服务器或调用特定 API;而 Computer Use 完全跳过了这些中间环节,它像人类一样直接注视屏幕、敲击键盘、滑动鼠标。这种拟人化交互让 Agent 继承了人类操作任何现代桌面软件的全部潜能,它本质上已经成为模型操作数字世界的基础通用 API。
> “You know, computer use works with everything. And it works by using the application the same way a human uses it, which I think is something worth understanding if you haven't spent much time with this technology. same way a human does, it makes the agent have all the capabilities you do, which I think is so powerful.” —— Ari Weinstein
- **交互模糊度容错**:借助类似撰写简要产品需求(Product Spec)的意图表达,配合 Flexible Input 机制,Agent 能自主补全上下文,无需严苛的形式化 prompt。
- **零适配成本**:绕过 API 与协议孤岛,只要人类能用浏览器或客户端打开的软件,Agent 就能直接理解并操作。
---
### `17:41` 消除企业顾虑:确定性沙箱、防注入与拟人化动效
尽管技术专家对计算机使用技术充满信心,但企业用户在落地时往往心存顾虑,常以“人类虽然操作慢且偶尔出错,但责任明确且受过合规培训”为由提出抗拒。为了打破这种信任壁垒,OpenAI 构建了纵深防御体系。除了模型底层具备极强的对齐水平与防 Prompt Injection 能力外,最核心的举措是向企业 IT 管理员交付“确定性控制(Deterministic Controls)”。
企业无需依赖概率性的模型道德承诺,而是可以直接通过刚性沙箱划定边界:明确限定 Agent 只能唤起指定的几款软件或访问白名单域名。此外,系统内置了行为拦截规则,例如在检测到文件上传、下载或跨域跳转至未知网站时强制挂起,等待管理员审批。为了消除新技术的疏离感与黑盒恐惧,产品在交互细节上也做了打磨:屏幕上保留了可视化的光标轨迹,以生动有趣的平滑动效实时展示 Agent 的点击与移动,让复杂的自动化过程变得直观且可被感知,帮助用户在日常使用中逐步建立信任。
> “The first layer is like, how do we create deterministic controls? I think that's really what gives, you know, enterprises a lot of feeling of safety is when they can, even though our model is the most aligned ever.” —— James Sun
- **确定性策略沙箱**:基于应用与网络域名的硬隔离,管理员可精准划定 Agent 的可操作半径。
- **敏感动作强行切断**:针对数据外发、文件下载等高危网络行为设置强制确认机制。
- **可视化信任设计**:通过定制化的光标动态渲染与清晰的步骤回放,将“未知魔法”转化为清晰可审计的人机协作视觉流。
### `20:00` 构建信任:光标交互设计与企业端“枯燥机会”
智能体在操作电脑时,界面的交互模式对于建立用户信任至关重要。与会者提到,看到诸如 Codex 风格的光标在屏幕上灵巧地点击操作,给用户带来了一种直观且安心的体验,让人不再担心 AI 会在后台失控乱搞。正如与会者所总结的:“你总会需要这样一个建立信任的时刻,去摸索那是一种怎样的感觉,以及你到底希望它为你做些什么。”
当讨论转向目前模型推理成本大幅下降、性能足够强大,企业最应优先将哪些场景自动化时,James Sun 提出了一个核心观点:把所有枯燥的记录系统(Systems of Record)彻底自动化。对话中大家笑称“枯燥即机遇(Boring as opportunity)”,这些在传统企业中消耗大量人力的琐碎流程,正是计算机使用(Computer Use)智能体最能大显身手的沃土。
```mermaid
flowchart TD
accTitle: 传统企业繁琐流程的智能体替代方案
accDescr: 展示跨部门采购和财务对账如何从人工表格流转升级为智能体端到端自动化。
subgraph Legacy ["传统人工流转方式"]
A["业务团队填写超大表格 (1000+ 行)"] --> B["运营团队手动录入内部采购软件"]
B --> C["系统生成杂乱明细条目"]
C --> D["采购团队人工联系供应商沟通"]
end
subgraph Agentic ["智能体自动化流程"]
E["跨多账本自动调取无 API 数据"] --> F["跨系统对账并自动标记异常"]
F --> G["直接驱动 UI 完成采购与 CRM 录入"]
end
```
- **采购管理(Procurement)**:例如在订购实验室设备时,以往通常是团队填写上千行的巨大电子表格,再由运营团队人肉搬运录入内部采购系统,最后由采购团队根据输出去联系供应商。智能体可以直接打通这一长串流程。
- **财务对账(Finance Reconciliation)**:公司内部充斥着各种不同的支出和资金账本。月末对账时,绝大多数老旧财务软件根本没有现成 API 可用。智能体能像人类一样直接在电脑上翻阅各个账本核对数据、发现异常,并生成待审查的标记。
- **销售线索录入(Sales Prospecting)**:销售团队需要处理会议记录、多平台数据抓取,智能体可以自动提取背景信息,直接点开并录入到 CRM 或外联邮件系统中。
- **竞品调研(Market Research)**:James 分享了自己业余开发羽毛球(Badminton)视频标注分析软件的经历。为了借鉴匹克球(Pickleball)、壁球(Squash)和网球同类产品的优点,他直接让智能体去各大竞品网站注册账号、试用产品、截图并生成功能反馈报告,省去了海量手动调研时间。
- **高阶视觉与工程设计**:随着多模态模型视觉设计能力的爆发,电路设计、硬件工程、建筑绘图以及游戏设计也正在成为智能体探索的新边界。
---
### `25:00` 消费端长尾需求、旧软件寿命与软件形态的演进
在消费级(C端)场景中,智能体同样展现出了两面性:一面是处理日常生活琐事(如自动填写车辆管理局 DMV 表格、退订成堆的垃圾邮件),另一面则是解锁那些由于原本“过于耗时”而让人望而却步的个性化需求。Ari Weinstein 提到,他平时用智能体来管理自己的个人财务表格和膳食计划表,甚至有健身教练朋友用它为学员一键生成完全定制化的训练计划。Ari 笑称自己使用的是小众软件 Apple Numbers,但模型依然能游刃有余地完美操作;而关于软件交互形态的根本演变,Ari Weinstein 展望道:“我认为随着时间的推移,由于这项技术的出现,软件本身的形态规格(Form Factor)将会发生改变,对此我感到非常兴奋。”
针对这一演进趋势,主持团队提出了一个尖锐的产业疑问:未来世界到底会变成“老牌巨头屹立不倒,智能体沦为套在30年前老旧 ERP 上的操作外壳”,还是会被彻底重构的“AI 原生(AI-native)新软件”取而代之?
Ari 认为这两者将在相当长的时间内并存。一方面,重构软件的成本与门槛降到了前所未有的低点;但另一方面,现实世界中运行着大量编写于十年前、二十年乃至三四十年前的生产系统,这些系统绝不可能在一夜之间灰飞烟灭。智能体的普及反而会成为一种倒逼力量,迫使各类软件(如借助 WebMCP 等协议)更好地原生支持智能体自动化操作。
关于未来是否会变成“没有 UI、全靠冷冰冰的智能体互相对话”的世界,James Sun 给出了非常明确的反驳。他认为软件开发充满着“手工艺(Art and Craft)”的温度与美感:
> “如果互联网沦为那种毫无个性的东西,全都是智能体彼此在交谈,而人类不再去亲自使用任何东西,那我将会非常伤心。”
为了阐明这一点,James 分享了一个温馨的生活细节:他的妻子最近迷上了在线五子棋(Omok,联五子棋盘游戏),但在网上老被高手虐。于是 James 亲自动手,为妻子专门定制打造了一款五子棋战术走法训练器。因为他深知妻子的学习喜好与使用习惯,这种精心打磨的个性化软件带来了极其愉悦的体验。他坚信图形用户界面(UI)绝不会消失:智能体可以在对局结束后为人类总结复盘错误,但人类在享受交互、进行沉浸式学习体验时,依然需要直观、优美且极具温度的人机交互界面。
### `30:00` 软件范式的转变:从千人一面到百人专享与共享智能层
讨论围绕着人类与软件的交互本能展开。Ari Weinstein 指出,人类在生理结构上就偏好“直接操纵”(direct manipulation),渴望亲手触碰和移动事物。过去的软件因为面向数以千万甚至数十亿计的用户,不得不采取“千人一面”(one size fits all)的设计。但在 AI 时代,软件完全可以针对极少数人甚至仅仅一百人进行量身定制。Seema Amble 提出了一个认知模型:消费级软件侧重于交互与学习中的愉悦感;而在企业级(B2B)领域,虽然用户希望 Agent 能接管繁琐的执行链条,但仍保留了审计日志(audit log)等个性化控制需求——人类设定规则与目标,由 Agent 落实执行,同时保证人类拥有恰到好处的控制权与赏心悦目的界面。Ari Weinstein 极为犀利地吐槽道:
> “Like, why should we settle for shitty software?”
他坚信未来将诞生兼具传统优雅 UI 与底层 Agent 自动化的全新软件,甚至由 Agent 通过计算机使用能力(Computer Use)去操控那些陈旧难用的老旧系统,包装出体验出色的新产品。James Sun 补充指出了“共享智能层”(shared intelligence layer)的必要性:如果每个网站都有互不连通的独立 Agent,整个数字世界将变得极其割裂。未来的关键在于让专属 Agent 能够接入其他软件的上下文,协同运转。
```mermaid
flowchart LR
accTitle: 现代用户界面与老旧系统的 Agent 衔接架构
accDescr: 用户在定制化新 UI 中设定目标,Agent 在共享智能层解析逻辑,并通过 Computer Use 驱动多套底层老旧系统。
subgraph UserLayer["用户层"]
U["人类用户"] -->|"设定目标与审计规则"| UI["定制化现代 UI"]
end
subgraph AgentLayer["共享智能层"]
UI --> AG["核心 Agent"]
AG -->|"状态与日志反馈"| UI
end
subgraph LegacyLayer["执行系统"]
AG -->|"Computer Use 自动化"| L1["老旧 ERP 软件"]
AG -->|"无 API 模拟交互"| L2["采购 / 报销系统"]
end
```
### `33:15` 初创企业的破局点:人机协同与垂直场景的“深耕护城河”
当被问及“如果今天重新创办一家面向企业的 Agent 公司该如何做”时,Ari Weinstein 建议创业者首先厘清产品的协作模态(modality):究竟是做让团队成员更高效办公的端侧人机协作,还是做在云端后台自主跑流程的系统?这直接决定了人类何时参与闭环(Human-in-the-loop)——Agent 究竟该在何时向人类报警、何时汇报成功,以及如何进行智能摘要以避免无意义的通知轰炸。
作为前创业者,James Sun 表达了对初创团队的坚定看好。他透露,即便 OpenAI 现有数千人规模,内部面对庞大命题依然感到捉襟见肘(stretched thin)。他认为大模型实验室绝不可能包揽一切,初创公司的真正护城河在于速度与对特定行业痛点的极致理解。
> “And speed, really, I think, at the end of the day, speed and pain is kind of the moat that exists today.”
- **大厂的精力限制**:前沿实验室资源被核心模型与基础能力占满,垂直行业的监管规则、客户支持与 GTM(走入市场)流程是初创团队的天赋领域。
- **AI 渗透迟缓的垂直行业**:例如餐饮连锁集团,有团队利用 Computer Use 结合视觉模型,通过拍摄后厨仓储照片推算次日缺料,自动在 Shopee 等采购网站下单,并联动排班 ERP 调整人手。
- **打破“旧金山技术泡沫”**:科技圈往往以为只要安装一个 Codec 或模型就能解决问题,但绝大多数传统 SMB 和企业连工具能力的边界都不了解;打通离散软件的端到端(end-to-end)流程并做出手感极佳的交互,蕴藏着巨大的商业机遇。
### `37:37` 前沿演进与体验统一:打造消费级连贯体验
展望计算机使用能力的未来演进,Ari Weinstein 强调了执行速度、超越人类专家级水准(superhuman),以及多模态输入输出融合带来的流畅交互体验。目前的 Agent 大多偏向在后台“离线”运行(用户派发任务后去做其他事情),未来则会演化出更多与用户在桌面上即时协作的高频互动场景。
James Sun 则指出了当前产品形态中最直观的痛点——碎片化与状态割裂。无论是云端虚拟电脑(Dots)、ChatGPT 内置的云端浏览器,还是本地桌面客户端及 Chrome 浏览器扩展,各自的 Cookie、密码管理器和标签页状态完全互不相通。
> “It’s kind of like an oxymoron because I think computer use is actually the most easy to understand AI product because it’s an AI using a computer. But then because of the complexities of the different states you have to manage and the different places you’re using it, the implementation details sometimes seep through and then it becomes kind of hard to grok.”
- **超人类速度与即时互动**:让计算机使用能力从单纯的后台异步批处理任务,进化为敏捷响应的前台人机并行协作。
- **抹平底层实现细节**:隐藏多套浏览器沙盒、云端实例与本地环境的身份验证与状态差异,避免让普通用户面对割裂的状态同步问题。
- **推动消费级普及**:目标在接下来的几个季度内,将 Computer Use 从硬核极客和技术前沿企业的专利,打造成人人都能直观理解、无缝使用的真正消费级产品。
### `40:00` 从“适应软件”到“软件主动适应人”:人机交互的认知摩擦
讨论转向了当前 AI Agent 产品面临的深层交互瓶颈。即使底层能力大幅提升,现实中依然是由人类发起并触发 Agent 的运作。如果用户界面(UI)与控制机制设计得越顺手、越让人享受,用户从中获得的价值才会越大。Ari Weinstein 指出,当前这类产品最大的痛点在于认知负担——用户在使用前必须先停下来思考该如何利用它,必须时刻提醒自己去用它,还要努力说服自己改变早已根深蒂固的操作习惯。
```mermaid
flowchart TD
accTitle: AI Agent 交互范式演进
accDescr: 对比传统被动唤醒与未来主动自适应的人机交互流向
subgraph Current["当前交互范式(高认知摩擦)"]
A["人类用户"] -->|"费力改变习惯 / 刻意唤醒"| B["被动等待的 Agent"]
B -->|"执行具体步骤"| C["完成既定任务"]
end
subgraph Future["未来主动交互范式"]
D["人类设定并把控总体目标"]
D -.->|"后台持续对齐"| E["主动式 Agent"]
E -->|"根据上下文主动适应用户"| D
E -->|"自动化解复杂工作流"| F["端到端价值交付"]
end
```
未来的破局点在于“主动性”(proactivity)。AI 不应当强迫用户去学习如何操作一套复杂的机器,而应该能够主动感知场景、自适应用户的个人工作流。正如 Ari Weinstein 所描绘的那种真正让人兴奋的人机关系:“我非常期待这样一个世界:由 Agent 来适应你,而不是你被动去适应它。”在这种模式下,普通人更容易理解并融入这项技术,而人类则保留最具决定性的角色——充当那个设定方向、掌控最终目标的舵手。
- 当前痛点:用户面临巨大的认知转换成本,必须在现有习惯之外“刻意记住”去唤起 Agent。
- 进化方向:Agent 将具备更多主动预判能力,使人机交互更加自然流畅。
- 人类角色:不再疲于琐碎步骤的配置,而是专注于核心目标的设定与方向把控。
### `41:40` OpenAI 的演进历程:从 Atlas 浏览器的摸索到“计算机使用”的指数级爆发
Ari Weinstein 和 James Sun 回顾了过去数月内部推动 Computer Use(计算机使用)的真实历程。这并非一蹴而就的技术突击,而是伴随模型能力跨越而逐步成型的系统工程。Ari 提到,过去六到九个月里发生的变化极其迅猛:研发团队在今年早些时候取得了关键的模型突破,让模型处理这类交互任务的能力发生质的飞跃;紧接着,内部多个团队全力以赴探索如何将其封装为优秀的产品级体验。就在最近几个月内,产品迎来了爆发式增长,用户真切感受到了自动化操作带来的颠覆性价值。
James Sun 分享了更具体的项目变迁。他在 1 月加入 OpenAI,当时负责的是 Atlas 项目(内部代号项目)。尽管团队倾注了心血,但他打趣地说道:“我喜欢 Atlas,安息吧 Atlas(Rip Atlas)。”他们逐渐意识到,在旧产品中单纯塞入 Agent 体验并没有打动用户,绝大多数人依然只把它当成一个普通的浏览器来输入网页。真正的拐点发生在最近几月:当模型自身具备了真正的浏览器端与屏幕级操作能力后,团队将这种 Computer Use 深度整合进现存的各类具备 Agent 属性的产品中,增长瞬间爆发。James Sun 感叹道:“它的周环比增长简直堪比 Y Combinator(YC)孵化出的明星项目。”
- 研发节奏:年初由研究团队在核心模型上取得关键突破,后续数月集中攻坚工程化 Harness 与产品化体验。
- Atlas 的教训:单纯在浏览器内嵌 Agent 无法改变用户的心智模型,用户倾向于将其视作普通浏览器。
- 爆发拐点:底层模型通用能力提升后,将浏览器控制能力下沉至全线 Agent 产品,带来了指数级激增。
### `43:08` 走出桌面端:将“云端超级计算机”交给每一位手机用户
随着 Computer Use 进入爆发期,未来的核心落脚点在于计算平台的泛化与下沉。James Sun 深入剖析了桌面端(Desktop)的固有局限:桌面环境在很大程度上仍然是极客和重度技术专家(Power Users)的专属领地。尽管科技从业者整天坐在多显示器前办公,但全球绝大部分普通消费者日常生活和数字交互的唯一中枢其实是手机。
因此,下一个决定性的转折点正是“云端能力(Cloud)”。与其强求用户去买一台电脑或学习繁琐的桌面系统,不如借助云端运行的虚拟计算机,把这种操作算力透明地递送给每一个移动端用户。James Sun 展望道:“你如何给每一个仅仅用手机过日常生活的普通人,赋予一台他们甚至都不需要懂得怎么操作、就能替他们把事情搞定的强大计算机?”一旦将后台强大的通用计算环境封装进普通聊天界面或移动应用中,计算机使用 Agent 才能真正冲出极客圈层,触达数以十亿计的全球大众。
Ari Weinstein 对此总结道:“我认为我们正处于‘计算机使用’无论是面向消费者还是面向企业的规模化爆发拐点(scaling moment)。”当连贯一致的体验逐步建立,原本高门槛的操作将被彻底抹平,用户会像信任一位熟练助手那样托付复杂的任务。
- 硬件鸿沟:桌面设备是重度专业用户的壁垒;全球海量终端用户高度依赖移动端。
- 云端赋能:通过云端虚拟计算机环境,让手机端的单次对话就能调动完整桌面系统的操作能力。
- 规模化拐点:随着控制链条、稳定性和安全护栏成熟,面向 ToC(普通消费者)与 ToB(企业级业务)的规模化扩张正在同步发生。
- 结语致谢:主持人们总结了计算机使用 Agent 的澎湃势头,随着产品体验愈发自然连贯,这场变革正加速融入主流计算范式。
## Notable quotes
> `43:08` 我认为我们正处于‘计算机使用’无论是面向消费者还是面向企业的规模化爆发拐点(scaling moment)。 — Ari Weinstein
> `40:00` 我非常期待这样一个世界:由 Agent 来适应你,而不是你被动去适应它。 — Ari Weinstein
> `25:00` 如果互联网沦为那种毫无个性的东西,全都是智能体彼此在交谈,而人类不再去亲自使用任何东西,那我将会非常伤心。 — James Sun
## Mentioned
Ari Weinstein, James Sun, Seema Amble, Fabrizio Serafini, OpenAI, a16z, Astra, Dots, Codex, Guardian, WebMCP, Atlas, Microsoft Paint, Google Calendar, Gmail, Slack, Sentry, Apple Numbers, Shopee, Y Combinator, Fallout
## Video description
AI agents are approaching a point where they can use computers faster than expert humans, turning the user interface itself into a universal way for AI to interact with software. OpenAI’s Ari Weinstein and James Sun argue that computer use is now entering its scaling moment, as better models, faster execution, and stronger safety controls make agents practical for more consumer and enterprise work.
Ari and James join a16z’s Seema Amble and Fabrizio Serafini to explain how computer-using agents are already navigating legacy ERPs, reconciling financial data, handling procurement, and operating software without APIs or custom integrations. They also discuss why the harness around the model can matter as much as model intelligence, how enterprises can set deterministic guardrails around agent behavior, and why computer use could simultaneously extend the life of legacy software and accelerate the arrival of new AI-native applications.
Looking ahead, they make the case for a more proactive and fluid relationship with computers, where agents work in the background, collaborate with users in real time, and increasingly adapt to us rather than requiring us to learn how to use them.
[Source](https://mgln.ai/e/1344/afp-848985-injected.calisto.simplecastaudio.com/3f86df7b-51c6-4101-88a2-550dba782de8/episodes/2c129b5d-535b-4c40-a104-2d0a66853196/audio/128/default.mp3?aid=rss_feed&awCollectionId=3f86df7b-51c6-4101-88a2-550dba782de8&awEpisodeId=2c129b5d-535b-4c40-a104-2d0a66853196&feed=JGE3yC0V)
Source quotes
[43:08] Ari Weinstein: 我认为我们正处于‘计算机使用’无论是面向消费者还是面向企业的规模化爆发拐点(scaling moment)。
[40:00] Ari Weinstein: 我非常期待这样一个世界:由 Agent 来适应你,而不是你被动去适应它。
[25:00] James Sun: 如果互联网沦为那种毫无个性的东西,全都是智能体彼此在交谈,而人类不再去亲自使用任何东西,那我将会非常伤心。
Source quotes
[8:32] Ari Weinstein: We've gotten computer use now to a place where it's faster than the average human at using a computer.
[41:15] Ari Weinstein: I think we're at the scaling moment of computer use, both for consumer and enterprise at the same time.
[40:00] Ari Weinstein: I'm really excited about a world where the agent can sort of adapt to you instead of you adapting to it.
Original transcript
[0:00] We've gotten computer use now to a place where it's faster than the average human. And I think we're getting really close where it is superhuman. What sorts of tasks do you think are ready to hand over to the agent versus the ones like, okay, it still requires some checking and correcting. Computer using agents now since Astra is now capable of doing anything that a person can do. We think a lot about like what new consumer experiences can we enable with a faster, better model. And then on the enterprise side, that's kind of naturally why the safety becomes more interesting. to control the amount of queue in the loop there is and then the auditability. It's unlike any other thing that we've built where the developer has to do some work to adopt it. Someone has to build a connector or MCP server. You know, computer users work with everything. Now we have, like, capable models. They're getting, like, cheap enough to run at scale. What should kind of companies think of automating? I think of it as in two big categories. The first category is, like... AI agents can increasingly use the same software we do, navigating websites, and completing work without dedicated APIs. What changes when they become faster at it than we are? A16Z's Sima Amble and Fabrizio Serafini joined OpenAI's Ari Weinstein and James Sun to explore the rapid progress in computer-using agents and why computer use could become a universal interface for AI. They discussed how agents could automate tasks across legacy enterprise software, finance, procurement, and sales, driving progress, including why the harness surrounding the model can nearly double its speed. They also examine how enterprises can control and audit agents. And what comes next? AI that proactively works in the background, collaborates with us in real time, and eventually navigates software faster than expert humans. Welcome to the A16Z podcast. I'm Sima Amble. I'm joined by my colleague Fabrizio Serafini. computer-using agents and how they're starting to do the real work inside companies. Today, I'm joined by Ari Weinstein and James Sun from OpenAI, who are going to help unpack what is going on with computer-using agents from their perspective and share some thoughts on the future. Ari, James, thanks for joining us. Of course. Happy to be here. Yeah, thanks for having us. Ari, kick it off and tell us a little bit about what in Astra has made computer-using agents move forward and what's really unlocked. so many things. are, Computer use models were already so good before Astra, you know, like Sol itself is amazing at computer use. So Astra really helps with a few things around the edges in my sort of anecdotal experience. One is it is a little bit faster on average because it uses fewer thinking tokens to do the same task. It's better at certain kinds of creative work. Like, for example, we had this demo where in our launch video where you were talking to it and it's drawing things on Microsoft Paint. tasks also. And then the last thing I find is it's just more reliable around the edges. It's kind of, I feel like I trust it a little more. It's sort of the kind of thing where there's a little difference that is hard to perceive, but really important between something being 99% reliable and 97% reliable. And I feel like it's sort of just a little higher in a way that feels pretty, pretty concrete. Yeah, and I think adding on to some of those things, Astra is also our most aligned model. Yeah, right. And so talking about trust a little bit. Yeah. If you look at the system card for it, it is much better at being resistant to prompt injection. It's much better at not taking any kind of unintended actions. And so when you think about it for like enterprise work, especially for companies using it for sensitive things, whether it's procurement or talking to vendors or talking to customers, you're going to feel a lot safer kind of using it. And that's really, really exciting. the creative side, I think internally we had Astra play video games against 5.6 and it wins every time. And so there are some cool tweets that people have made where Astra is able to beat Fallout in 30 hours or something like that. And so it's also just really amazing at playing video games. So I don't know, that probably translates to something, but yeah. Maybe just a double click on that point. Consumer versus enterprise use cases of muting agents, very, very different computer using agents. How do you guys think about where things are more exciting between consumer and enterprise if you were to pick? I think our goal at OpenAI is really about building products that's useful for everyone. And so actually, it's interesting because Ari is definitely more of a consumer guy here. And I spend a little bit more time on the enterprise side. I think the consumer is always the place where we try to push the frontier on what's possible. With Astra, like Ari mentioned, it's much faster compared to previous models. And so we think a lot And then on the enterprise side, it's kind of naturally why the safety becomes more interesting. Because I think at the enterprise, whenever we talk to a large company,
[5:00] companies. I think the use cases for computer use is actually fairly obvious, right? Inside enterprises, there's lots of legacy software that doesn't have any MCP tools. They are software that's been used for 15, 20 years. And so a lot of times it's actually kind of hard to use for a normal person. Lots of UI that is from the last decade. And so you don't even know how to operate some of the key things. And so we've seen companies build skills that kind of teach the model to be able to use them better. have been there maybe for a little bit longer and the companies are catching up and trying to understand how to deal with it. And consumers where we're trying to figure out the next types of use cases that's not maybe possible today with software. Maybe you can share a little more. Yeah, I mean... The consumer use cases are so fun for me because it's kind of like, How can you... put your agent to work doing the things in your daily life that are so annoying and save you tons of time and just have more time to focus on the things that you're excited about. I think it's been really fun to see Dot, where each Dot gets its own computer and you can ask it to do things for you in the cloud. It gets a full web browser. It can buy things for you. It can book haircut appointments and anything else you want us to do. So that's been really fun. And I think there's a lot more on the horizon. It's going to be really fun. Yeah, no, that was going to be my question on dots. I think, James, you probably... use a dot to walk through product feedback. It would be cool if you could share more about it. I'm just so curious to know on your end, guys, how are you using dots and how does computer use play into what you can do with them? Yeah, I mean, I think dots is really cool for a few reasons, right? One is really proactive. And so I've I've been very surprised a lot of times when, in both my personal life and work, when dots will just flag something that I just completely slipped through the cracks, right? Just the other day. So internally, like on our email system... Whenever we get an external email for an invite, it doesn't actually show up on our calendars. And so I end up missing a bunch of external meetings. And so Dots now is catching these things for me. It's like, oh, there's this invite that's in your inbox. It's not on your calendar. Do you want me to accept it in your Gmail so it shows up? So that's being a lifesaver. It's a small thing, but it matters a lot. But I also have it proactively kind of looking at... I think it's really good at proactively looking for tasks where the shape of it is not super... let's say, concrete every single time. So an example that I also have it set up to do is we use Slack internally. And there's a ton of messages that's going on at all times. And I used to have this Slack job using automations and codecs that's every hour or every 30 minutes go and try to pull things. And I've just ended up tuning out a lot of the notifications because it's just sometimes useful, sometimes a dot. With dots, I can give kind of a high-level goal. It's like, hey, if anybody in my reporting chain says anything, flag it to me, right? If anybody who's giving some critical feedback, about certain products, go for it. And then because it has a cloud computer, I've had this pretty cool workflow where when someone reports, they usually have a Sentry log. I could have it go use the cloud computer, actually drive my local browser while the dot's going to control both your local computer as well as the cloud computer, log into Sentry, pull the logs, analyze it, give me feedback. And so it's saving that entire loop of figuring out which feedback's important, looking at it, Then going to Sentry, downloading their logs, feeding into Codex, asking for thoughts, and all that can now just kind of be automated. And so, yeah, Dots is great for at least these proactive and kind of long running tasks where they're not the same shape every single time. We talked a little bit about reliability, speed, token usage and efficiency. How do you guys think about balancing all of these things as you keep making improvements on what you're releasing? I think we're really excited about computer use at OpenAI. We've invested in it a lot, and we've gotten to a place where I think we have the fastest, cheapest, and most reliable computer use product. And I think there's actually so much further we can take that. We spend a lot of time looking at speed. Speed is really interesting because on one hand, the power of computer use is it can do tasks in the background. So in some cases, it doesn't matter how long it takes because you can be going and doing other things while it's accomplishing the task for you. But also sometimes you want to watch it to make sure it does it correctly. You need to wait for it because it needs to complete this before because you don't want to get this feeling like, oh, I could have just done that myself and it would have been so much easier. So we've gotten computer use now to a place where it's faster than the average human at using a computer. And I think we're getting really close to a place where it is superhuman, meaning it is faster than an expert computer user like probably one of us at this table. And I think that's going to actually be a sea change when that happens. I think it's going to change the way we all interact with computers because all of a sudden, you really want to do it yourself for some reason, which I think actually there may be many reasons people would want to do that. But in a default case, you probably just want the agent to do it for you. And I think that's going to let us build all kinds of cool user experiences. So speed is something we think about a lot. And then obviously we have a strategy of offering multiple different models.
[10:00] multiple different qualities and price points. And so for different use cases, you may want to use a different model. At the same time, our less expensive models are getting much better at computer use over time. And so I think there will actually be more variation over time in which models people want to use for which tasks. I think that's what I was saying. I think the other thought is, how do we give customers control over the... safety, reliability, autonomy versus speed, right? Like if you have, like, you know, when the model is slow, you can kind of watch it do stuff, but then you're limited to the tasks that you can do because you can't just sit here watching the thing doing it. Like it's actually less effective, right? Because it's slower than you. But once you can get to a point where you can no longer observe and audit everything it's doing, how do we give, especially enterprises and businesses, the ability to control the amount of and then the auditability, right? I think a few months ago, I was part of Axtra, I thought a few months ago. As part of Astra, you know, we kind of launched a set of enterprise controls that let businesses choose one, like how much human in the loop is there? Like, do they want, the agent to automatically approve everything. We have this really awesome system called Guardian, I think auto-approve in the app, that is a really smart model looking at every single action that the computer use agent is taking to decide if it's safe, if it's aligned to their original intent. A consumer might be like, I just want it to do everything, and I don't want it be asked for approval, whereas an enterprise is able to kind of decide which type of actions actually go through. And so I think the control part becomes more and more important as our computer use agents become also superhuman in doing things. Totally. I think as you try to, you know, roll out more enterprise use cases, I think Employers are excited about the efficiency, but they're also wary of what's being unleashed. Maybe even on the other side, have you guys seen the response from application software around, okay, now there's computer-using agents accessing my legacy workflow software? And do you guys think at all about that? Are you more focused on just the agent that's being used by the consumer enterprise user? actually. I think when it's like, within software that is approved and used by the company, it's actually more straightforward because it's like, oh yeah, 100%, we want to have... people automate and do work in here that they don't have to do tediously themselves. But when it comes to the internet, I think you kind of have a few different camps of folks, right? One is we... run of a business model is not in line with having agents use their product, right? You think about advertisers, publishers, whose business model is entirely on advertisement. If the agent's using the website for them, then they're not in line with having agents use their product. Where's that revenue coming from? And I think most places, an agent's ad impression does not actually count towards real revenue. And so that's an interesting question that we're always working through and working with our partnerships team on. There's another question kind of around for the companies who do really want to embrace having computer use agents using their sites. A lot of them are adopting kind of standards that let. humans or people and agents to be able to use it together. So like WebMCP is a standard that we're really excited about. We add a support for it in the in-app browser. And so you can kind of imagine these scenarios where the agent is elevating the experience of using the site. but it's not entirely replacing it. So I think browsing the internet is still very fun, in my opinion, right? I still like doing shopping. I still like looking at all the hotels and flights and places. And so you can imagine places where the product, The agent does... all the tedious work, but it kind of carves out an user experience where you're doing the browsing, you're like, okay, now I want to finish the transaction and then put in my credit card and do all this stuff, then you can hand it back to the agent. And so WebMCP is kind of an interesting way where your interface with the website is still the site itself versus an API, but then the person is kind of using it together. And so those are some thoughts. Shifting gears, I want to double-click a little bit on what it means to do the job or get the end-to-end job done. We'd love to hear a little bit from you guys How do you guys define the right narrow, repeatable task? And what sorts of tasks do you think are ready to hand over to the agent versus the ones like, okay, it still requires some checking and correcting on the user side? I mean, generally, I found the model to be pretty capable to do anything that you can do on a computer now. And one exercise that I try to force myself to do is that whenever I have a task, the first thing I think about is just kind of just have the agent do it. some sensitivities around, you know, if I'm sending a message to someone, I want to feel like it's coming from me. But in general, I think the way I think about it is computer using agents now since Astra is now capable of doing anything that a person can do.
[15:00] And there are... questions around, I think, before of like, oh, there are some like squishiness around like specificity and requirements. I've generally found that the model is getting pretty good at whenever you're asking to do something and there's some vagueness, it will actually, you know, with Astro, I think we launched this like flexible input, right? And so we'll actually ask you about, hey, like, I want some details. And if you don't answer in time, we'll just keep going and then pull the context that's necessary. I think there are some things around, you know, if you have the requirements are at least similar to writing a product spec. But in general, I think, I generally feel like unless there is something incredibly sensitive that you want to be in the loop for, I just reach for the capabilities model for everything I do now. I'm curious if it's the same for you. Yeah, it is. I'm trying to build that impulse to reach right now because it's so good and sometimes it's so easy to get locked into the old way of doing things. I... I think the really cool thing about computer use as a technology is the universality of it. You know, it works with every application. It's unlike any other thing that we've built where, you know, the developer has to do some work to adopt it. Someone has to build a connector or MCP server. You know, computer use works with everything. And it works by using the application the same way a human uses it, which I think is something worth understanding if you haven't spent much time with this technology. same way a human does, it makes the agent have all the capabilities you do, which I think is so powerful. Yeah, and I guess adding on to what I was saying, part of it is like, I think over time, I've stopped thinking about it as like, am I using them like a computer use task or a non-computer task? Frequently, they're like connected, right? Like the way we think about computer use is that like computer use is not like a thing you pick up and just say, I want to do something. It's really like the universal kind of API that the model has to do whatever it takes. And so maybe the only time that I... I don't reach for computer use for some cases is if the task is so simple that then it's easier for me to just go and like click two buttons and do it. But, you know, as computers gets faster, even faster than the question becomes, maybe I don't need to do that. I just, you know, drive voice and it just uses the computer with me. So those are some interesting thoughts there too. Do you think there's anything you have to... share with an enterprise user to get them comfortable with that. Obviously, you guys are totally pilled on computer use, but I think there's obviously hesitance sometimes on the enterprise user of like, okay, well, yes, the human would click through it and probably do it worse. But there is that feeling of there's accountability and that person's trained and all the classic kind of rebuttals. I'm curious to convince people around. I think the main thing is, We think about it as two layers, right? The first layer is like, how do we create deterministic controls? I think that's really what gives, you know, enterprises a lot of feeling of safety is when they can, even though our model is the most aligned ever. And it's, I think, better, you know, better than most people at, you know, protecting against prompt injections and unintended things because it's like just, you know, the intelligence is so smart. But I think there is just the feeling of safety when the enterprise admins can basically say for certain tasks or for certain data sources, used. And so we see kind of enterprises. So we launched was two things, right? One is the ability to be able to deterministically create a sandbox around your agent. So being able to say it can use certain apps, it can use other apps, it can use certain websites and other websites. And then two is, you know, this kind of part of a human in the loop, like what type of actions does it require a human to be intervening? And so we might say, okay, for any time there's like a download and upload, a person has to kind of approve it. Anytime it goes to a new website, a person has to approve it. Now again, these are all like dials and enterprise can kind of go through. And so it's really like that's one. And then two is really just showing the enterprise admins just how, all the evals that we've run internally around how aligned these models are, even compared to both internal and third-party models. emails. I think there's also some baseline stuff that we do across the board to just try to help people build trust with these kinds of products. We know it's so new, it's such a magical and sometimes alien experience for people. And so, we put a lot of work into the design of the product so you can always see the cursor if you want to watch it perform a task and it sort of animates in a fun way so it's not boring to watch. And then, like James was saying, this is very customizable for enterprises, but also for a regular user, we ask you for permission before using a new application or
[20:00] website, depending on which sort of modes you're in. And I think that helps people sort of not feel like it's going to go do some runaway stuff on their computer. You kind of want to have this trust building moment where you figure out what it feels like and what you want it to do for you. And then you sort of feel more comfortable over time. The Codex cursor is so cute. I love it. It's like such a, I know it's a small detail, but like watching it use the computer gives you like experience point. That's worth, that's definitely worth investing on. And I guess I'm curious, like in a broader sense, like, okay, now we have like capable models, They're getting cheap enough to run at scale. In your view, what should kind of companies think of automating? Like, where do you see the most promising kind of use cases in, within enterprises? Are there some workflows, maybe something around the ERP, maybe something around kind of how, like, again, humans and agents can work together to get tasks done? But like, if you have to, like, pick where are you most excited to see your models perform in the world, like, Yeah, I guess like from my perspective, I'd love to hear Aries. It's like two, I think of it as in two big categories. The first category is like automating, you know, tedious workflows. That's like the more boring one. And I'll give us some boring examples. Boring as opportunity. Boring as opportunity. Yeah, exactly. Like ERPs is a really big one. And so all the acronyms you can think of, ERPs, CRMs. All the systems of record. you're ordering a bunch of lab equipment. Instead of having this giant spreadsheet with like a thousand rows and then the ops team, it's like, you know, work to one company is like, Normally what they have done is they have this giant spreadsheet that gets filled out by the teams themselves. Then an ops team takes that giant spreadsheet, puts it into an internal procurement software, and then that gets finalized as a bunch of lines. And then a sales team then goes, procurement team then takes that giant software output and then goes out and reaches out to vendors. Computers can automate all of that, right? So procurement is a big one we see. Finance is another really interesting category we've seen. So, you know, There's a lot of different ledgers within a company, right? And so you have like ledgers for expenses, ledgers for all these things. And so at the end of the month, there's a lot of reconciliation. And a lot of these financial software don't have APIs to be able to quickly pull things. And so the finance team being able to have computer use, look through all these ledgers, reconcile, pull out anything that's like interesting to flag either to a person or then do some investigation. Also a very boring but useful workflow for their sales team. Teams uses a lot of different software for like transcripts, for getting data, all these kind of things. And so having computer use go and do prospecting and then going and putting that into a CRM or some kind of like, you know, outreach software and then all that. So all the system records is the boring part. And then like market research, another one that we see a lot. And so, you know, in my free time, I've been building this like video annotation software for Badminton, a lot of Badminton. I like to film myself playing the game and then having the agent kind of go and look at stuff. And I was like, OK, how do I make this thing really useful? There's some software out there for like pickleball, for squash, for tennis. And so I just had computer use, go log in, create an account on these softwares, try it, take screenshots, give me feedback and then try to build it back into the app. And so these are all kind of like tedious workflows that could be done. we talked about the model now being really good with like visual, visual design. And so circuit design, you know, being able to like architecture work, hardware engineering, game design. These are also areas that I think we're really excited about where the Astro can take. Less, you know, less common for enterprises to think about those right now because they're thinking about the boring opportunities. But I think as folks understand the capabilities of the model more, that's where I think we'll kind of see more usage next. But curious for any thoughts, sorry. Yeah, I think kind of similarly on the consumer side, there's a lot of things where it's sort of automating drudgery or just doing things you don't want to do. It's filling out DMV forms for you. It's helping you unsubscribe from a bunch of emails in your inbox. And then I think there's also things that are more like I'm hearing from a lot of people's stories of people doing things that they just wouldn't have time. They wouldn't have had time or wouldn't have thought to do otherwise. Like, I don't for me personally, I'm. maintaining spreadsheets about my finance and spreadsheets about meal planning. And I have a friend who's a personal trainer who's making customized
[25:00] things for his clients. And, you know, some of these things would just be so, so time prohibitive to do in your, in your personal life. But this makes it so easy. I use Apple Numbers, which is like a obscure spreadsheet program, but the model still knocks it out. I don't think I've ever heard someone use Apple Numbers. It's a surprisingly great spreadsheet software. And then I think there's a third category of thing, which I'm kind of the most excited about, which is just starting. and I think, you know, on the horizon, you know, which is really just having a different way to use your entire computer or interface with software. I think you saw in our Astra ad, really cool examples of people just talk to their computer with their voice. It's such a natural way to use your computer. And I think over time, we're going to see the form factor of software itself change due to this technology. And I'm really excited about that. On that point okay form factor of software changing Imagine if you an enterprise user you used to using whatever clunky ERP from 30 years ago There a world in which you now unleash a set of agents that just operate that software and you don really care There another world in which folks are a new like AI native player is using a computer using agent And I curious if do you think the world is going to go more in the direction of like keep the legacy folks and just have this layer on top? Or do you think computer using agents can absolutely be part of new software players? And this is something I think a lot about. So I'm curious to get your guys' thoughts. It is such an interesting moment where simultaneously the cost and complexity of creating new software is so much lower. So you can't imagine software changing so much, but also there exists so much legacy software in the world that computer use is so well-suited to interact with. So I expect both of those things to continue for a long time. You know, if you look at the software that's in production today, a lot of it was written 10, 20, 30, 40 years ago, and I don't think that that stuff's going to go away overnight. I do think that in some way the existence of computer use may put more pressure on companies to make software work better with agents because all the software is going to work with agents by default. And I think WebMCP is a great example of this. And I think we'll see more stuff like that. So, yeah, I sort of expect both to be super important. But I do think it like kind of shift over time What do you think James Yeah I agree with you I think it like the way there a lot of arts and crafts And you understand this because Ari built a beautiful product with his team. The cursor was all in. And so I think there's like a lot of art and craft into building like great products that people can hold in their hand. And I don't know, like for me, if we go, if the internet becomes just this like faceless, you know, thing that is just agents talking to each other and people are not using anything anymore, I would be very sad. And I don't think it will be like that because like there is like something about craftsmanship and artisan software that's like just feels nice to use because the person who designed it really, really understands like the experience that the customer wants to have. So like my wife loves is recently got into playing this like, you know, board game. I forgot the name of it. It's where you connect like five pebbles to like win. I think it's like OMOC is the name of it. And so anyway, so she's trying to get good at it because she's playing online with friends and is getting her ass kicked. And so I was like, all right, I'm going to build you like a tactical trainer for, you know going through different gambits so you can like get better at it Like that for example something that like I you know created a first version i was like oh i know like she likes to do it in a certain way she likes these type of uh ways to learn more than others and so i was able to like you know craft the software to be something like feels really good for her and like these kind of personalized software i know it's like i think maybe today still feels like only really tech people will do but i think if you like think about this a few years out it's like if anybody can build anything and they can build these really craft software in a very short amount of time for like niche use cases that are like so well tailored for people. I think that's a beautiful world. And again, you know, at the end of her training, the lessons and mistakes she made, that could be an agent that summarizes it and gives her in a text format. But when she's actually playing with the with the AI and trying to get better, that's something that the person has to do. So I do think it's, I'm more, I'm bullish that I don't think UI is going away. And I think kind of at the low tangential to your original question, but I do think that the pressure of cheap software will make it so that software has to be better. But I don't think it will just be like, yeah, everything will have an MCP and an API and, you know, computer use will never be useful. Totally. I love this point so much. I think that like humans are so
[30:00] hardwired for direct manipulation. You really want to be able to, you know, move and do things with your own hands. And I think that it's really exciting to think about how software in the past was so one size fits all. It had to be, you know, often a lot of the software we interact with every day is designed for millions, tens of millions, hundreds of millions, billions of people. And I think we will enter an era where any piece of software could be designed for a hundred people personal and unique that kind of software will be. Yeah, my mental model is I think there's probably two buckets. One is on the consumer side, you've got either something you just get, you get joy out of, you enjoy using, or you learn from, there is this, it's not the utility of it, it's the joy of interacting or learning or whatever it is, and you want to spend time. On the On the B2B side, you may want your agent to complete a bunch of the tedious work, but you also, there's this concept of like the audit log. And that could be personalized in how you want to interact. But the product really is me as the human user setting the goal and then being able to understand the logic, but not necessarily need to run through the entire chain of command of how it happened. to say, okay, pay this person at this time, yeah, at 30 days, this much discount should be applied, et cetera. They want the agent to take care of like the execution of it, but they want to be able to at some level, like some level of control still needs to be put in there. And I think that's like something that does require a UI of some sort. And it has to be, I think if we're moving more towards believing that AI will do more of this, that part has to be enjoyable to use too, why not? Like, why should we settle for shitty software? You know, it's, I do think it'll be really interesting to see if we, and I'm... optimistic that we will see new kinds of software where it has traditional user interfaces, but is also using agents under the hood. And then maybe sometimes those agents are themselves using computer use to automate legacy software by giving you some much nicer, more purpose built experience. I'm like really excited for that class. Yeah, it's kind of like the one where we like to use internal, it's like the shared intelligence layer, right? You have your agent, you're using legacy software somewhere else and doing things at other places. If you're using an application, the application wants to get access to that context so it's able to deliver a better experience. I think if we had every website has its own agent that doesn't talk to your agent, it's a very fragmented world. And so figuring out how that plays together, where the agent can plug in and use your other software, I think it's going to be a really interesting thing to play out for the next few months. I love that you guys... Yeah, talk about this, because I think it's so underappreciated, the importance of like human AI interaction, especially if you want like a product to be successful. So like being thoughtful of like, how can I kind of. Like, humans are used to collaborate, so you want any agent to be able to, like, kind of fit into the team. I'm just curious, like, if you apply that to a new startup, let's say you're, like, I don't know, starting a company tomorrow, and you want to use computer use to, like, solve a workflow within the enterprise, how would you think about it? Just like maybe if you had to talk to founders right now, what advice would you give them as they try to use your models and capabilities to just solve problems for enterprises? In my mind, it depends on. It depends so much on the modality of, you know, Are you trying to are you a small team and you want sort of individual on the team to be able to use some piece of software that that your that your team is using, but in a more efficient way. Or are you maybe building something that itself wants to interact with existing software, in which case maybe you have some, you know, machine in the cloud somewhere that's doing computer use in the background? I think that will really affect the modality of how you want the human agent collaboration to be. Right. And yeah, you know, in the former case, I think a lot of our products are serving this use case, you know, where you sit down at ChatGPT and, you know, there's a lot of great collaboration you can have there. And in the other case, you know, if you're building something with the API, you're doing your own computer use implementation, then, yeah, then it really is interesting to figure out when do you want the human to be in the loop? Is the agent telling you when something's wrong? Is it telling you when something went right? You know, is something summarizing that so that you don't get bombarded with notifications saying, hey, this happened, this happened.
[35:00] happened, which actually you're going to ignore. I don't know. What do you think, James? Yeah, I mean, you know, both Ari and I were startup founders before we went to OpenAI. And so, you know, I'm still very bullish on startups. You know, I think the question, right, kind of comes down to like, what, is there still a mo, right? Is there something that startups can still tackle while labs are doing things? I mean, in general, I just think there's like two things. One is like, I think there's so many things to build, right? And like, even though we're quite big now, thousands of people, we are still feeling very stretched thin internally. It's like the teams are not very big for all the problems. And so if you have a problem that you really deeply understand, you have industry expertise, you understand how regulatory works, the go-to-market motion, how to service those customers, it is still, I think, a very green field out there. And the tools that you have through our APIs, like Ari mentioned with computer use, I think will still let you accelerate. And speed, really, I think, at the end of the day, speed and pain is kind of the moat that exists today. I think the other thing I think about a lot is there are, in my opinion, still a lot of vertical industries where the diffusion of AI is much slower. And so I was talking to a company the other day who uses computer use to help restaurant groups to take pictures of their back storage And then using that, the vision looks at what is going to be missing based on a projection for tomorrow's traffic. And then it takes that to then use computer use to go to a Shopee or some kind of procurement software to then order your groceries for the next day. And then based on that, it will go into your ERP to adjust the timetable for your employees who you might need more people to help. Because in the last year, at this time of the day, there was a lot more traffic coming in from holiday or something like that. And so those restaurant groups are probably not like tech companies that are super familiar with all the tools that are available. And so I think like, you know, living in San Francisco, we see a lot of thinking, wow, like the labs can do everything, the codecs and like, you know, why doesn't it just install codecs and just have it do stuff? But like for the average American and the average small, medium business owner, the average enterprise, even understanding what the tools are capable is one. Connecting tools in a way that makes sense is two. Deploying it is three. Servicing is four. And so there still a lot in my opinion where if there are complex workflows that require a lot of disparate software computer use is a great way to join them complete the entire IntendNor flow and then building it in a format and UI that feels good to hold for those customers feels still like a really, really big opportunity that I think is still open. Tell us about what's next. What are you excited about that's on the frontier that you can share around computer using agents? Well, I've sort of gestured towards it already, but we're really excited about speed. We're really excited about making computer use superhuman. And we're really excited about things that blend together different kinds of interfaces that bring together sort of multimodal inputs and outputs. So you can have more kind of fluid experiences with your computer. I think right now a lot of our computer use product is very background focused. It's very much like, let me give the agent a task so it can do that while I do something else, which is actually a tremendous strength, right, of the product. But I think that in the future, we'll also see more of this like real time collaboration between you and the agent. So I'm really excited about this area. And otherwise just sort of better cheaper more available easier to use Yeah exactly Being able to actually access everything Yeah I think there is you know with Dots right where we giving folks these like computer in the cloud ChatGPT work also has a browser in the cloud I think, honestly, like for me, like one thing I'm excited about is just making the experience feel a little bit more coherent. Like, you know, today you can install the Chrome extension and that uses your like password manager and everything in Chrome. And then we have an in-app browser in the desktop app, which has a different set of cookies and different passwords. your computer in the cloud also has different things. And for the average consumer, it's confusing. It's like, why do I have these four different browsers that all don't talk to each other? If I open up a tab in one, does it show up in the other? And so I think a lot of what I'm excited about is how do we make computer use go from this product that is used by enterprises and really hardcore tip of the spear kind of users to something that's actually understandable for people. It's kind of like an oxymoron because I think computer use is actually the most easy to understand AI product because it's an AI using a computer. But then because of the complexities of the different states you have to manage and the different places you're using it, the implementation details sometimes seep through and then it becomes kind of hard to grok. And so being able to kind of make that consumer grade and easier to understand, more coherent is something I'm really excited about for the next quarter.
[40:00] And I think it comes back to the point that there is still a human that's setting off the agent, right? And they have to, the better the UI and controls and the easier and more enjoyable it is to use, the more they're going to get out of it. And that's... Absolutely. On that point, one other thing I want to gesture towards is I think another challenge of the product today is you you have to put some thought into how you're going to use it and you have to remember to use it and you have to convince yourself to do things that are different from how you're used to doing them. and help you solve problems. I think we'll also see a lot more proactivity. I'm really excited about a world where the agent can sort of adapt to you instead of you adapting to it. And I think that we're going to see a lot of that. And I think it will make it a lot easier for people to actually like relate to and understand and incorporate this technology while also still being the one sort of setting and steering the goals, if that makes sense. One of the things we your use and how much has changed. And Fabrizio and I chatted a little bit about this in our piece. Would love for you to just kind of talk about where it's, you know, how it's the trajectories so far and where things are headed. Yeah. I mean, James and I have been working on computer use for some time now at OpenAI. And it's been an incredibly exciting past like six to nine months, right? Because we started working on these computer use products and very few people were me became great at these kinds of tasks earlier this year because of amazing work the research team did. And then we've been working super hard with a bunch of teams internally on how to create actually good product experiences around this. And then just in the past couple of months, all of a sudden, you know, the product's growing like crazy and people are really seeing the value in it. But I think it's still so early, you know, it's still the case that only some, you know, going to see it grow quite a bit. Yeah, totally. I mean, you know, I joined OpenAI in January, and I joined working on the Atlas product. And I love Atlas, Rip Atlas. But the, I think, you know, one of the things that we realized was, um, In the Atlas product, the agentic experience, I think for a few reasons, wasn't actually like a big selling point. Not many people used it, partly because I think most people treated it like a normal browser. And over the last few months, because the model capabilities have gotten better, we've now incorporated browser and browser use into kind of all of our existing products where there was already agentic usage. We've just seen... It's like YC level of growth week over week. And then I'm always surprised by how fast it can go. And I think this next big inflection point is cloud. How do we... Desktop is still very much... a power user thing. I know we probably use our desktop all the time, but like most consumers are on their phones. And so how do you give every single... chat to the user, how to give everybody who's just using their phone for their day to day life, a powerful computer that they don't even need to understand how to use, that it just kind of makes things work for them. And so I'm really excited about how that kind of brings it to, you know, building users. It feels like computer using agents have had a ton of momentum behind them. And now it's the moment of like, okay, how do we get it into more people's hands? They trust it. They feel like they can really use it. And to your point earlier about coherent experiences, that's a real, I think as that gets a lot better, I think consumers will feel more comfortable using it and it'll feel more natural. I think that's right. I think we're at the scaling moment of computer use, both for consumer and enterprise at the same time. Yeah, really excited to see where it goes and what people go with it. Nice. Us too. All right. Well, thank you so much for joining us. This was awesome. We love talking about this topic, and it was really fun to hear it from you guys directly. Thank you. Yeah, a lot of fun as well. Yeah, thanks. Thank you. Thank you, guys. Apple Podcasts, and Spotify. Follow us on X at A16Z and subscribe to our Substack at a16z.substack.com. Thanks again for listening, and I'll see you in the next episode. the companies discussed in this podcast.
[45:00] For more details, including a link to our investments, please see a16z.com forward slash disclosures.