OpenAI Moves Codex to Cloud to End Local Hardware Bottlenecks

OpenAI

Engineering teams must shift execution from local laptops to persistent cloud environments and proactive agents to sustain multi-day autonomous software development.

AI-assisted summary of Codex Has Left The Laptop | DevDay 2026 — original source. Check the original for full context.

Source published: 2026-10-09

Key ideas

OpenAI introduced Codex Cloud, Dots, and unified @ChatGPT integrations across Slack and Teams to eliminate the need for running long tasks on physical laptops or self-managed VPS setups. (0:00)
Codex Cloud automates environment provisioning by analyzing repositories, writing custom startup skills and scripts, and taking filesystem snapshots for accelerated launch times. (3:40)
Enterprise and staging resources can be accessed securely within Codex Cloud via Tailscale peer integration and OpenID Connect (OIDC) authentication without exposing endpoints to the public internet. (8:00)
Proactive personal 'Dots' monitor channels and triage pull requests with access to user context and private vaults, whereas team-facing @ChatGPT interacts strictly within shared organizational cloud environments. (14:40)
The Codex CLI now incorporates an Agent View to track parallel threads, terminal Voice Mode via GPT Live, and native diagram rendering alongside a browser-based web experience in Chrome. (17:20)

Detailed notes

## Background Published by OpenAI on YouTube on October 7, 2026, this DevDay 2026 presentation explores the latest updates to Codex across the CLI, desktop application, and web. According to the page description, the session uses live demonstrations to show developers how to transition from assigning isolated tasks to letting Codex independently resolve complex engineering problems and objectives.

## TL;DR Dominic from OpenAI's developer experience team details the architectural shift from running autonomous agents locally on half-open laptops or self-managed hardware to running them natively on Codex Cloud. Through practical live demos, he showcases headless environment provisioning, secure private networking via Tailscale, interactive Figma plugin workflows, and collaborative PR reviews in the desktop app and Space. The talk highlights how personal proactive 'Dots' and team-facing `@ChatGPT` integrations in Slack empower developers to supervise long-running background tasks from anywhere without physical hardware constraints.

## Atmosphere & style The presentation carries the polished, energetic optimism typical of a flagship developer keynote, balanced by honest, relatable humor about real developer pain points like propping laptops open to keep scripts alive. Dominic delivers an enthusiastic, hands-on walkthrough with technical credibility, smoothly laughing off a live keynote service glitch before pivoting to working backup runs. It feels like an intimate, visionary deep dive that demystifies a dizzying pace of AI updates into clear, actionable patterns for everyday software engineering.

## Bulletin - [00:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=0s) OpenAI introduced Codex Cloud, Dots, and unified @ChatGPT integrations across Slack and Teams to eliminate the need for running long tasks on physical laptops or self-managed VPS setups. - [03:40](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=220s) Codex Cloud automates environment provisioning by analyzing repositories, writing custom startup skills and scripts, and taking filesystem snapshots for accelerated launch times. - [08:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=480s) Enterprise and staging resources can be accessed securely within Codex Cloud via Tailscale peer integration and OpenID Connect (OIDC) authentication without exposing endpoints to the public internet. - [14:40](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=880s) Proactive personal 'Dots' monitor channels and triage pull requests with access to user context and private vaults, whereas team-facing @ChatGPT interacts strictly within shared organizational cloud environments. - [17:20](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=1040s) The Codex CLI now incorporates an Agent View to track parallel threads, terminal Voice Mode via GPT Live, and native diagram rendering alongside a browser-based web experience in Chrome.

## Key takeaways - [00:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=0s) Long-running autonomous agent tasks previously led developers to keep laptops half-open or buy dedicated hardware, spurring the transition to managed cloud infrastructure. - [00:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=0s) Codex Cloud, Dots, and Slack/Teams integrations operate on a shared unified agent harness that preserves existing account plugins and tools. - [03:40](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=220s) Codex Cloud can provision multi-repo isolated workspaces and automatically generate startup scripts alongside environment skills. - [03:40](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=220s) Filesystem snapshotting accelerates subsequent environment boots, while background sync keeps repositories up-to-date with upstream changes. - [05:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=300s) Codex detects cross-platform execution boundaries, such as flagging that iOS builds cannot run inside a Linux container while still retaining mobile source editing capabilities. - [06:05](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=365s) Integrated Figma plugins enable Codex to ingest design tokens, build features, generate verification recordings, and deploy interactive web playgrounds. - [08:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=480s) Tailscale tunnels and OIDC authentication let Codex Cloud agents securely query private internal infrastructure, such as on-premise hardware, without public internet exposure. - [10:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=600s) Developers can separate shared cloud environment variables from personal vault secrets that remain hidden from teammates. - [10:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=600s) Invoking @ChatGPT in Slack allows the agent to spin up shared cloud environments, inspect related pull requests and Figma designs, and refine branches directly in thread conversations. - [12:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=720s) The overhauled Code Review tab provides a conversational diff review interface where engineers can probe potential side effects and delegate entire PR evaluations to Codex. - [12:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=720s) Spaces functions as a collaborative canvas where agents and humans co-author living specifications, complete with auto-updating architecture diagrams and task checklists. - [14:40](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=880s) Personal Dots proactively track discussions and run tasks with access to individual memory, whereas @ChatGPT is scoped to collaborative threads and shared organizational environments. - [17:20](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=1040s) The CLI Agent View allows engineers to monitor, manage, and spin up multiple concurrent Codex threads directly from the terminal. - [17:20](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=1040s) Codex CLI adds real-time terminal Voice Mode powered by GPT Live, plugin mentions, and native terminal rendering for diagrams and LaTeX. - [17:20](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=1040s) Codex Cloud on the web delivers full task run histories, preview deployments, and upcoming parity with the desktop app's dedicated Code Review tab. - [19:55](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=1195s) Developers are urged to shift from short, prompt-based micro-tasks to production-grade delegation by adopting Codex Cloud, Spaces, and proactive Dots.

## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=0s) The Shift from Local Laptops to Autonomous Agents

Dominic from OpenAI's developer experience team takes the stage, noting that Sam Altman had introduced around 20 new features earlier that day, compounding roughly 300 features released over the previous year. Building with this rapid influx of tooling has completely transformed engineering workflows at OpenAI and across the wider developer community. Dominic acknowledges that the sheer volume of updates can feel overwhelming and confusing, framing his talk around practical patterns to integrate these capabilities directly into daily routines.

Reflecting on how developer habits evolved, Dominic recalls that at the start of the year, running one or two tasks in parallel felt standard. Seeing Peter Steinberger tweet about juggling 40 simultaneous Codex instances once seemed unimaginable. However, the release of the Codex app normalized high-volume task delegation and rapid context switching. As underlying models developed stronger computer-use skills and greater autonomy for long-running work, developers began delegating problems that executed over hours or days. This introduced a humorous, real-world complication: engineers started wandering around carrying laptops half-open between meetings just to prevent sleep mode from terminating active tasks.

Many developers responded to this friction by purchasing dedicated hardware—such as a Mac mini or a Raspberry Pi—or renting virtual private servers (VPS) purely to keep their autonomous agents alive. However, managing extra hardware creates new administrative burdens, from disk space limits and system updates to ongoing procurement hurdles whenever capacity demands increase. Dominic emphasizes that task delegation should not be tied to physical device management: "delegating work should be as easy as just telling Codex to do something, and it picks up the work regardless of whether you have to go and procure more computers." To realize that vision across interfaces, OpenAI introduced Codex Cloud, Dots, and `@ChatGPT` integrations for Slack and Microsoft Teams. All of these entry points share the same unified Codex agent harness, honoring existing account plugins and tools without requiring developers to rebuild setups from scratch.

```mermaid flowchart TD accTitle: Codex Architecture Evolution accDescr: Evolution of Codex from local laptop execution to multi-device workarounds to managed cloud environments.

subgraph Phase1["1. Local Laptop Era"] A["Single/Dual Tasks"] --> B["Long-Running Work"] B --> C["Laptops Kept Half-Open"] end

subgraph Phase2["2. Self-Managed Machines"] C --> D["Local Procurement: Mac mini / Pi / VPS"] D --> E["Maintenance Overhead: Updates & Disk Space"] end

subgraph Phase3["3. Unified Codex Harness"] E --> F["Codex Cloud"] F --> G["Slack & Teams (@ChatGPT)"] F --> H["Desktop App Remote Workspaces"] F --> I["Dots Integration"] end ```

[03:40](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=220s) Provisioning Cloud Environments in the Desktop App

Moving to live demonstrations, Dominic opens the Codex desktop app to show how developers can bypass local execution in favor of remote instances hosted on Codex Cloud. Users can either attach tasks to existing team-shared environments or provision fresh environments configured around specific codebases.

Dominic sets up an environment by selecting two repositories from "Blossom Music," an example project introduced earlier by Holly. Once the repositories are selected, Codex autonomously takes over the setup process. Rather than forcing the engineer through brittle boilerplate and dependency wrestling, Codex inspects the repositories, identifies dependencies, and writes both a startup skill (teaching the agent how to navigate and operate within that specific environment) and a startup script designed for rapid iteration.

- Supports multi-repo selection within a single isolated environment. - Automatically generates custom environment skills and startup scripts. - Implements filesystem snapshotting to ensure subsequent task launches boot significantly faster. - Executes background updates to sync repos with upstream changes and run maintenance tasks continuously.

[05:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=300s) Dependency Discovery and Cross-Platform Boundaries

As the environment boots, Codex analyzes the project dependencies and flags a platform-specific constraint. The workspace contains both web and iOS codebases running inside a standard Linux container. Codex intelligently detects that it cannot compile or emulate the iOS application within the Linux host. Dominic explains that this outcome is entirely acceptable for his workflow: the agent merely needs access to the iOS source code for cross-referencing and editing, while bypassing local mobile compilation. He adds that future platform updates will allow users to bring their own custom cloud environments to tailor execution runtimes to any architecture.

```mermaid flowchart LR accTitle: Codex Automated Cloud Provisioning Flow accDescr: How Codex Cloud provisions multi-repo workspaces and writes operational skills.

A["Select Repositories (Blossom Music Web + iOS)"] --> B["Codex Inspects Repos"] B --> C["Dependency & Platform Analysis"] C --> D["Generate Startup Script"] C --> E["Generate Startup Skill"] C --> F{"Detect iOS on Linux"} F -->|"Constraint"| G["Disable Mobile Emulation"] F -->|"Supported"| H["Allow Source Referencing & Editing"] ```

[06:05](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=365s) End-to-End Implementation: Figma Plugins and Live Playgrounds

Dominic pivots to an earlier task to demonstrate the capabilities of Codex Cloud when combined with OpenAI's plugin ecosystem. Starting with a snapshot of a visual shader designed in Figma, Dominic sent the asset directly into his Codex Cloud environment. Operating independently, Codex utilized the installed Figma plugin to pull design tokens and specifications directly from the Figma file.

From those design inputs, Codex implemented the shader code, ran unit and integration tests, and generated a verification video recording. Because the cloud harness links directly with surrounding ecosystem tools, Dominic took the workflow a step further: he instructed the agent to deploy the compiled shader as an interactive web playground. Through the hosted web preview, engineers can tweak visual properties directly, evaluate performance, and push configuration updates back to the codebase prior to production deployments. Within the desktop app interface, users retain the same interactive controls they have locally: - Inline code review to inspect diffs and leave contextual line comments. - Side chats anchored to the executed task for follow-up questions and iterative refinements. - Automated web deployments for rapid manual verification.

[08:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=480s) Private Networking with Tailscale and OIDC

A common barrier preventing teams from adopting cloud-based coding agents is network isolation: remote agents often lack access to internal staging resources, staging databases, or private microservices that are barred from the public internet. Dominic illustrates how Codex Cloud tackles this limitation by demonstrating a local API running on a physical Raspberry Pi sitting on stage, completely disconnected from the public web.

To grant secure, isolated access, Dominic configured his cloud workspace with a Tailscale authentication key, allowing Codex to join his private tailnet as a peer device. In addition to Tailscale, Codex Cloud incorporates OpenID Connect (OIDC) support for enterprise authentication against protected cloud infrastructure. To demonstrate the boundary, Dominic shows that curling the Raspberry Pi's port over the open internet produces no response, while connecting his laptop to the same tailnet immediately returns live data.

Despite encountering an unexpected keynote service glitch—joking that "You might have noticed we had some outages during the keynote. There's some working on it"—Dominic pulls up a backup run showing the agent querying the Raspberry Pi over the Tailscale tunnel. The cloud-hosted Codex agent queried the internal API, gathered the necessary payloads, and completed its tasks without exposing any private endpoints to the broader internet. Returning to the automated workspace initialization started earlier, Dominic shows that Codex finished provisioning the Blossom Music repositories: it confirmed it would skip iOS execution while preserving mobile editing, and outputted both a finalized installation script and startup instructions ready for immediate use.

[10:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=600s) Cloud Environment Configuration and Slack Collaboration

The cloud environment setup gives developers complete control over configuration, either by directly modifying files by hand or by instructing Codex to handle the adjustments. A dedicated startup skill outlines every prerequisite and detail needed for the project. From the setup screen, developers can fine-tune network access, define network secrets, and isolate environment variables—choosing between shared variables for the cloud environment or private secrets stored in a personal vault that teammates cannot see. Furthermore, environments can be kept private or shared across an entire organization. Because the execution runs entirely in the cloud, developers are no longer tied to their physical machines: they can simply close their laptops and continue monitoring or steering the tasks from a smartphone or web browser.

Moving these workloads to the cloud also allows agents to meet engineering teams where they already spend their time: in team messaging tools like Slack. During a demonstration of an active Slack conversation between the speaker and a colleague regarding a visual bug in their web application, the speaker brought in `@ChatGPT`. Rather than just spitting out speculative advice, the agent pulled up the relevant pull request, inspected the design assets inside Figma to see what was visually misaligned, and discovered that an open PR had already attempted a fix. When asked to dive deeper and verify the implementation, ChatGPT spun up the exact shared cloud environment previously configured, tested the code changes live, and helped refine the branch until the PR was completely ready for formal review.

```mermaid flowchart TD accTitle: Cloud Task Execution and Collaboration Workflow accDescr: Flow diagram showing how local setup leads to cloud execution, accessible via phone, browser, and Slack. subgraph Config["Environment Setup"] A["Startup Skill & Config"] --> B["Network & Vault Secrets"] B --> C["Share with Team / Self"] end subgraph Execution["Codex Cloud Engine"] C --> D["Headless Cloud Environment"] D --> E["Run Tests & Spin Up Previews"] end subgraph Interfaces["Anywhere Access"] D -.-> F["Mobile / Browser"] D -.-> G["Slack (@ChatGPT / Dot)"] G -->|"Inspects Figma & PRs"| E end ```

[12:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=720s) The Overhauled Code Review Tab and Living Specs in Spaces

As autonomous agents write an increasing share of code, human engineers spend far more of their working hours reviewing pull requests. In response, OpenAI overhauled the dedicated Code Review tab inside the desktop application. The tab aggregates every pull request assigned to or created by the developer in a single unified view. Engineers can inspect diffs, post inline comments, read peer feedback, and submit reviews, or delegate the entire review to Codex. Crucially, the app allows engineers to interrogate the PR conversationally: developers can prompt Codex directly inside the review interface to explain the PR's core objectives, uncover hidden edge cases, and flag downstream side effects before approving and submitting feedback.

For larger architectural work, planning and alignment become major friction points. "Space" acts as a collaborative canvas where both human teams and AI agents co-author specifications without tedious copy-pasting. Demonstrating a redesign of an API reference implementation and its deployment pipeline, the speaker had Codex draft an initial plan directly into Space. The document was then shared with human teammates for review while Codex continued refining it. The agent generated an interactive system architecture diagram to visualize service boundaries and inserted a dynamic task tracker. As Codex works through individual tasks, it updates its own progress live in the document. When multiple teammates collaborate, their respective personal agents and Codex instances all contribute to the same central document, keeping the entire organization synchronized before Codex implements the final plan.

- **Unified PR Inbox:** Aggregates PRs authored by or assigned to the engineer with full diff and comment histories. - **Conversational Side-Effect Analysis:** Allows engineers to chat with Codex directly inside the PR review UI to probe edge cases and architecture implications. - **Bi-Directional Living Documents:** Agents update task checklists and system diagrams in Space in real time as cloud execution advances.

[14:40](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=880s) Proactive Dots vs. Collaborative @ChatGPT in Slack

While many engineers rely on complex loops or recursive threads to organize delegated tasks, proactive agents—termed "dots"—fundamentally change how work is monitored. Dots continuously watch engineering discussions, track product threads, detect code changes, and spin up autonomous cloud tasks when necessary. In a real-world example, a colleague named Carlos tagged the speaker in an urgent PR late on a Sunday evening at 10:20 PM. Rather than opening a laptop off-hours, the speaker checked a Slack ping sent by his personal dot. When asked what the PR was about, the dot summarized the changes; when asked for a deep review, it automatically launched a dedicated cloud task directly from Slack, diagnosed the defects, and reported back with actionable findings that the speaker could follow up on later.

The speaker clarified the distinct roles between mentioning `@ChatGPT` and using a personal `Dot` in team workspaces: - **Your Dot (Personal Extension):** Explicitly named after the engineer (e.g., combining the user's name with the dot) to signal to team members that it carries the engineer's specific context, preferences, and memory. Dots hold permissions to monitor specific channels, weigh in on conversations, access private local Codex instances, and orchestrate private cloud environments. - **@ChatGPT (Shared Collaborator):** Designed for multi-user group threads where teammates interact with an agent simultaneously. To safeguard individual privacy, `@ChatGPT` only has access to shared organizational cloud environments rather than personal vaults or local machines.

```mermaid flowchart LR accTitle: Dot vs @ChatGPT Comparison accDescr: Diagram illustrating the boundaries and access models between a personal Dot and team-facing @ChatGPT. subgraph PersonalDot["Your Personal Dot"] PD["'Name's Dot'"] --> M["Personal Memory & Context"] PD --> LC["Local Codex & Vaults"] PD --> CE["Private Cloud Environments"] end subgraph TeamChatGPT["Team @ChatGPT"] CG["@ChatGPT in Channels"] --> ST["Thread Collaboration"] CG --> SCE["Shared Cloud Environments Only"] end ```

[17:20](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=1040s) CLI Power Features and Codex Cloud on the Web

For terminal purists, the Codex CLI received an overhaul centered on parallel agent orchestration and rich formatting. The CLI now includes an Agent View dashboard where developers can monitor every background Codex task running simultaneously, identify which agents require human attention, and spin up new parallel jobs without leaving the shell. The terminal client also supports `@mentions` across installed plugins, vastly faster text selection, and native terminal rendering for diagrams and LaTeX formatting. The CLI even incorporates interactive terminal Voice Mode powered by the GPT Live model, allowing engineers to speak directly to their terminal agent when their microphone is configured.

Simultaneously, Codex has expanded into standard web browsers like Google Chrome via Codex Cloud, removing the requirement to install the desktop application on every machine. Inside the browser, developers can review cloud task sessions, watch interaction screen recordings, and directly test live preview sites deployed by their agents. Web users can converse with their personal dots and inspect past snapshots. The speaker noted that full parity is imminent, with the desktop app's dedicated Code Review tab scheduled to arrive in the web interface in the coming days so developers can conduct deep agent-assisted reviews from any browser.

- **CLI Agent View:** Manage, track, and spin up multiple parallel agent threads in a single terminal interface. - **Terminal Rendering & Voice:** Full support for inline LaTeX equations, visual diagrams, plugin autocompletion, and live voice conversation. - **Browser-Based Codex Cloud:** Review task run histories, view app preview deployments, and conduct PR code reviews natively in Chrome.

[19:55](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=1195s) Moving from Prototypes to Production: Three Invitations

Over the past year, software engineering with AI has undergone a massive paradigm shift: moving away from piecemeal, prompt-by-prompt micro-tasks toward delegating end-to-end, ambitious engineering problems to autonomous systems. This transition enables developers to build durable, production-ready systems rather than throwaway prototypes. Acknowledging that teams do not need to overhaul their whole tech stack overnight, the speaker concluded with three concrete practices for developers to adopt:

1. **Adopt Codex Cloud:** "If you're still leaving your laptop cracked or managing a pile of dev boxes in whatever shape it is, try out Codex Cloud for your work." Reusing pre-baked cloud environments frees engineers from babysitting physical hardware and maintains continuity across machines. 2. **Standardize Specs in Spaces:** Rather than fragmenting project specs across siloed docs and manually copying requirements back and forth into prompt windows, use Space as a unified ground truth where human teams and Codex collaborate, update tasks, and track architecture together. 3. **Assign Ongoing Ownership to a Dot:** Instead of manually forwarding tickets and hand-crafting prompts every time a task surfaces, hand your dot ongoing responsibilities and let it proactively watch repos, triage pull requests, and keep engineering initiatives moving forward automatically.

## Notable quotes > [00:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=0s) delegating work should be as easy as just telling Codex to do something, and it picks up the work regardless of whether you have to go and procure more computers. — Dominic

> [08:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=480s) You might have noticed we had some outages during the keynote. There's some working on it — Dominic

> [19:55](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=1195s) If you're still leaving your laptop cracked or managing a pile of dev boxes in whatever shape it is, try out Codex Cloud for your work. — Dominic

## Mentioned OpenAI, Codex, Dominic, Sam Altman, Peter Steinberger, Holly, Carlos, Codex Cloud, Dots, ChatGPT, Slack, Microsoft Teams, Figma, Tailscale, OpenID Connect, Raspberry Pi, Mac mini, Space, GPT Live, Google Chrome

## Video description Explore what’s new in Codex across the CLI, app, and web. Through live demos, see how to move from delegating individual tasks to letting Codex tackle entire problems and goals.

[Source](https://www.youtube.com/watch?v=XkKdbPhIvbY)

中文简报

OpenAI将Codex迁至云端以消除本地硬件瓶颈工程团队必须将执行从本地笔记本电脑转向持久化云端环境和主动型智能体，以维持持续数天的自主软件开发。来自OpenAI开发者体验团队的Dominic详细阐述了架构层面的转变：从在半开的笔记本电脑或自托管硬件上本地运行自主智能体，转向在Codex Cloud上原生运行。通过实际的实时演示，他展示了无头环境预配、借助Tailscale实现的私有安全网络连接、交互式Figma插件工作流，以及在桌面应用和Space中的协作式PR审查。本次演讲重点介绍了个人主动型“Dots”以及Slack中面向团队的“@ChatGPT”集成，如何让开发者能够在不受物理硬件限制的情况下，随时随地监督长期运行的后台任务。 OpenAI推出了Codex Cloud、Dots以及跨Slack和Teams的统一@ChatGPT集成，旨在消除在实体笔记本电脑或自建VPS环境中运行长期任务的需求。 (0:00) Codex Cloud通过分析代码库、编写定制启动技能与脚本并生成文件系统快照来自动预配环境，从而加快启动速度。 (3:40) 企业和预发布资源可在Codex Cloud内通过Tailscale对等集成和OpenID Connect（OIDC）身份验证进行安全访问，无需将端点暴露给公网。 (8:00) 主动型个人“Dots”可访问用户上下文和私有密码库以监控频道并分诊审查拉取请求（PR），而面向团队的@ChatGPT则严格在共享的组织云环境中进行交互。 (14:40) Codex CLI现已集成了用于追踪并行线程的智能体视图（Agent View）、基于GPT Live的终端语音模式，以及原生图表渲染功能，并辅以Chrome中的浏览器端Web体验。 (17:20)

Reading summary

Dominic of OpenAI's developer experience team argues that autonomous AI development has outgrown local laptops, requiring persistent cloud environments, living technical specifications, and proactive background agents. Overcoming Local Hardware Bottlenecks with Codex Cloud (0:00) As developer workflows shifted from running single tasks to delegating long-running jobs that execute over hours or days, engineers faced physical hardware constraints. Developers frequently left laptops cracked open to avoid sleep mode interruptions or maintained dedicated Mac minis, Raspberry Pis, and virtual private servers, introducing ongoing administrative overhead such as disk management and system updates. Dominic asserts that delegation should not require managing physical devices. Codex Cloud addresses this by provisioning remote, headless environments directly from the Codex desktop app. When configured with codebases like the multi-repo Blossom Music demonstration, Codex autonomously inspects dependencies, writes tailored startup scripts, generates operational skills to navigate the repository, and creates filesystem snapshots to accelerate subsequent boot times. The platform also identifies environment limitations; for example, when running inside a standard Linux container, Codex detected that it could not emulate iOS applications, allowing developers to inspect and edit iOS source code while skipping compilation. Enterprise Networking and Toolchain Integration (8:00) A primary obstacle to adopting remote coding agents is network isolation from internal staging databases and private microservices. Codex Cloud integrates Tailscale authentication keys and OpenID Connect (OIDC) enterprise authentication, allowing the remote agent to join private tailnets as a peer device. During a demonstration featuring a disconnected, local Raspberry Pi on stage, the cloud agent queried the private API over the Tailscale tunnel without exposing the internal endpoints to the public internet. Codex Cloud also integrates directly with third-party tools to automate implementation workflows. In a demonstrated graphic shader task, the agent used an installed Figma plugin to extract design tokens and specifications directly from a design asset. Codex implemented the shader code, ran unit and integration tests, produced a verification video, and deployed an interactive web playground for real-time manual testing and diff inspection before production deployment. Conversational Code Review and Living Spaces (12:00) Because autonomous agents generate higher volumes of code, human developers spend more time reviewing pull requests. The desktop application features an overhauled Code Review tab that aggregates authored and assigned pull requests into a unified inbox. Beyond static diffs and comments, engineers can prompt Codex conversationally within the review UI to explain core objectives, probe for edge cases, and evaluate downstream architectural side effects. To align human teams and agents on broader architectural changes, OpenAI introduced 'Space' as a collaborative canvas. In a pipeline redesign demonstration, Codex co-authored living technical specifications alongside human engineers, embedding dynamic task checklists and system architecture diagrams. As personal agents and Codex instances make progress across cloud tasks, they update the centralized Space document in real time, preventing architectural drift. Proactive Personal Dots Versus Shared Team Collaborators (14:40) Codex interfaces extend beyond local environments into Slack, Microsoft Teams, the web browser, and an updated CLI featuring background Agent View management and terminal Voice Mode. Within team messaging, OpenAI distinguishes between personal 'Dots' and shared '@ChatGPT' agents to manage security and context. A personal Dot is explicitly named after an individual engineer, carrying that specific person's context, memory, and permissions to access personal secret vaults and private cloud instances. Dots operate proactively, monitoring channels off-hours to summarize urgent pull requests and launch autonomous diagnostic tasks. Conversely, mentioning '@ChatGPT' operates as an interactive group collaborator for team threads; to maintain user privacy, '@ChatGPT' is restricted solely to shared organizational cloud environments rather than private individual setups. Dominic concludes with three recommendations for transitioning from isolated prototypes to production: adopting persistent cloud environments rather than managing local machines, standardizing project requirements in collaborative Spaces, and delegating continuous monitoring and triage to proactive personal Dots.

Detailed notes — zh

## Background 本视频由 OpenAI 于 2026 年 10 月 9 日发布在 YouTube 平台上，是 DevDay 2026 的主题演讲之一。视频简介指出，本次分享主要探索 Codex 在 CLI、桌面应用和 Web 端的最新进展，并通过现场实时演示，展现开发者如何从委派单一零散的任务，跃迁到让 Codex 统筹解决完整的复杂工程问题与目标。 ## TL;DR OpenAI 开发者体验团队的 Dominic 介绍了全新发布的 Codex Cloud、个人智能体 Dot 以及集成在 Slack 和 Teams 中的 ChatGPT，旨在帮助开发者彻底摆脱为了维持长任务运行而“带着半合上的笔记本电脑奔走”或自行维护硬件的痛点。通过引入能够自动配置依赖的“启动技能（Startup Skill）”、文件快照加速以及结合 Tailscale 与 OIDC 的私有网络访问，Codex Cloud 将计算环境全面迁移至云端，并与 Figma、GitHub 及 Slack 实现无缝跨工具链协同。同时，Codex 重构了桌面端的“代码审查（Code Review）”面板、推出了统一规划与进度同步中枢“Spaces”，并将完整体验扩展至支持多代理视图与实时语音的 CLI 终端及 Web 浏览器。演讲最后鼓励开发者转向云端环境、利用 Spaces 协同，并将持续性的监控与推进职责交由主动式个人智能体 Dot 来完成。 ## Atmosphere & style 整场演讲风格务实、紧凑且极具工程师之间的共鸣感，Dominic 以开发者日常“抱着半合上的笔记本跑会”等真实痛点幽默开场，迅速拉近了与台下听众的距离。现场演示过程真实而充满生机，尽管接连遇到了演示视频加载小插曲、网络短暂波动以及终端语音模式麦克风未启用等直播突发状况，但演讲者都从容地以备用记录化解，并在观众善意的笑声中保持了流畅的节奏。从最初对密集新功能的应接不暇，到逐步展示多智能体在云端、终端与协作软件间行云流水般的配合，整场分享传递出一种将开发者从繁琐基建中解放出来、全面迈向高维人机协作的振奋感。 ## Bulletin - [00:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=0s) OpenAI 在 DevDay 2026 上正式发布了 Codex Cloud、个人主动式智能体 Dot 以及集成于 Slack 和 Teams 的 ChatGPT，旨在让长周期 AI 任务彻底脱离本地硬件限制。随着开发者从委派单点任务转向同时运行多达 40 个并行任务甚至耗时数天的复杂工程，这套云端与多端生态消除了维护本地服务器或“半合着笔记本电脑奔波”的运维痛点。 - [05:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=300s) Codex Cloud 支持自动分析代码库依赖并生成“启动技能（Startup Skill）”与脚本，利用文件系统快照大幅加速任务启动；同时结合 Tailscale VPN、OIDC 协议以及个人保险库（Vault）双层变量隔离机制，使云端代理能够安全访问树莓派等本地私有内网资源。 - [12:08](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=728s) 针对 AI 编码量激增带来的审查与协同瓶颈，Codex 重构了桌面端“Code Review”面板以辅助推演代码改动的潜在副作用，并推出“Spaces”统一协作中枢，允许人类团队与多个智能体在同一文档中自动同步系统架构图与实时开发进度。 - [14:42](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=882s) 新推出的个人智能体“Dot”具备全天候主动监听代码变更与讨论的能力，深度绑定开发者的个人记忆、私有 Vault 与本地环境；而 Slack 中的 `@ChatGPT` 则作为团队公共计算节点，仅调用共享云环境协同联动 GitHub PR 与 Figma 设计稿进行实机测试。 - [17:16](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=1036s) Codex 全面重构了 CLI 终端（新增多任务 Agent View、LaTeX 与图表原生渲染以及基于 GPT Live 的实时语音模式），并将完整桌面级体验扩展至 Web 浏览器，帮助开发者通过转向云端托管、统一协作中枢与持续性职责授权实现研发范式升级。 ## Key takeaways - [00:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=0s) 过去一年 OpenAI 陆续推出了约 300 项功能（本次开场发布约 20 项），开发者的工作模式已从运行一两个独立任务演变为同时并行调度多达 40 个甚至耗时数小时至数天的长周期 AI 代理任务。 - [00:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=0s) 为解决长周期任务迫使开发者“带着半合上的笔记本电脑四处奔走”或自行采购维护 Mac mini、树莓派及云端 VPS 的痛点，OpenAI 推出了共享同一核心代理与插件生态的 Codex Cloud、Dots 以及 Slack/Teams 集成版 ChatGPT。 - [05:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=300s) Codex Cloud 能自动检查代码仓库与依赖项，自动编写教导代理使用环境的“启动技能（Startup Skill）”和用于快速迭代的“启动脚本”，并通过文件系统快照优化与后台自动更新大幅提升后续任务的启动速度。 - [05:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=300s) 借助已安装的 Figma 等插件，Codex Cloud 可直接提取设计稿细节实现着色器代码并生成可交互的在线 Web Playground，开发者可在浏览器中测试参数、在代码行内留评或开启侧边聊天（Side Chat）。 - [06:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=360s) 通过配置 Tailscale VPN 授权密钥（Auth Key）与支持 OIDC（OpenID Connect）协议，Codex Cloud 能够在不将私有资产暴露给公共互联网的前提下，安全访问局域网内（如本地树莓派上）运行的私有 API。 - [10:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=600s) 云端环境支持通过自然语言或手动方式配置 Startup Skill，并提供精细的网络访问控制、Network Secrets 以及双层环境变量隔离（区分当前云环境生效的变量与存放在个人 Vault 保险库中的私有变量）。 - [10:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=600s) 在 Slack 频道中呼叫 `@ChatGPT` 排查问题时，模型不仅能自动检索对应的 GitHub Pull Request 并调取 Figma 设计稿进行像素级对比，还能直接唤醒团队共享的云端环境在隔离容器中跑通变更测试。 - [12:08](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=728s) 随着 AI 编写代码体量呈指数级增长，代码审查（Code Review）成为新的时间黑洞；重构后的桌面端审查面板聚合了所有相关 PR，支持调用 Codex 执行全自动初审并追问改动可能带来的潜在副作用（Side Effects）。 - [12:08](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=728s) “Spaces”协同载体消除了在聊天窗口与外部文档间复制粘贴信息的繁琐流程，支持在文档中由 Codex 生成系统架构图与任务进度看板，并由负责各子任务的 Dots 与 Codex 实例实时回写代码实现进度。 - [14:42](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=882s) 个人智能体“Dot”具备全天候主动感知能力，能监控产品讨论与代码库变更并主动创建任务（例如在周日晚上 10 点 20 分通过 Slack 提醒开发者被提及的 PR，按指令梳理提要并在后台启动完整的云端代码审查任务）。 - [14:42](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=882s) 在 Slack 协同边界上，个人“Dot”是开发者的数字延伸，绑定个人记忆、私人 Vault 并可调度本地 Codex 与个人云环境；而 `@ChatGPT` 则是面向团队公域的共享伙伴，仅拥有团队公开云环境的访问权限。 - [17:16](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=1036s) 重构后的新版 CLI 引入了可纵览所有并行任务的“Agent View”（智能体视图），新增插件 `@` 补全语法、原生图表与 LaTeX 数学公式渲染，并整合了接入 GPT Live 模型的低延迟实时语音模式（Voice Mode）。 - [17:16](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=1036s) Codex 完整能力已扩展至 Chrome 浏览器端，开发者无需安装客户端即可调阅云端任务流水线、查看应用快照（App Snapshot）与操作录屏回放、直接与临时部署站点交互，并支持连接个人 Dot 与使用即将上线的代码审查功能。 - [19:48](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=1188s) 软件工程范式已从“委派单个零散任务”转向“托付宏大目标与复杂问题”，官方建议开发者践行三大高杠杆工作流转变：全面转向 Codex Cloud 免除本地运维、使用 Spaces 建立统一协作中枢、将持续性职责（Ongoing Responsibility）授权给个人 Dot。 ## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=0s) OpenAI 开发者体验与 Codex 的演进历程 Dominic 作为 OpenAI 开发者体验团队的成员走上舞台。他首先提到，Sam 在开场时发布了大约 20 项新功能，加上过去一年中陆续推出的约 300 项功能，这些工具极大地改变了 OpenAI 内部以及广大开发者的构建方式。面对如此密集的更新，大家要想跟上节奏确实非常困难。因此，在接下来的 25 分钟里，他将通过一些实用的实际案例，向大家展示如何将这些新功能真正融入日常工作流中。回想今年年初时，大家通常还只是让 Codex 运行一两个单独的任务。但当看到 Peter 同时运行多达 40 个不同的 Codex 任务时，大家会觉得这种场景令人应接不暇、难以想象。不过，随着 OpenAI 推出 Codex 应用，任务的委派和切换变得异常简单。自那以后，同时运行多个 AI 代理几乎成了常态。随着模型变得越来越聪明、能力越来越强（尤其是在计算机使用和长时间运行的任务方面），大家开始把越来越大、越来越复杂的任务交托给模型，这些任务往往需要运行数小时甚至数天。随之而来的一个尴尬痛点是，开发者们开始带着半合上的笔记本电脑四处奔走，仅仅为了让它们在会议间隙继续保持运行。为了解决这个问题，许多人甚至自购了 Mac mini、树莓派（Raspberry Pi），或者租用云端 VPS 来专门跑代理。然而，更多的机器意味着更多的维护负担、磁盘空间管理、系统更新以及容量规划，每次想要扩展规模时都得额外采购硬件。Dominic 指出，委派工作应该像告诉 Codex 去做某事一样轻松，而不应让用户为采购电脑操心。用户应当能够在自己选择的任何界面上使用 Codex 运行框架，并自主决定任务在何处执行，从而根据自身需求灵活调整工作流。为了顺应这一需求，OpenAI 在 DevDay 2026 上正式发布了 Codex Cloud、Dots，以及集成在 Slack 和 Teams 中的 ChatGPT。所有这些新产品都运行在大家熟悉的核心 Codex 代理之上，这意味着用户可以通过账户中已安装的插件继续访问相同的工具和信息，而无需从头开始配置。 ```mermaid flowchart LR subgraph Users ["用户端"] A["CLI / Desktop App"] B["Slack & Teams"] C["Codex Cloud"] end subgraph Core ["核心引擎"] D["Codex Agent"] end subgraph Plugins ["插件与工具"] E["Figma 插件"] F["自定义插件"] end A --> D B --> D C --> D D --> E D --> F accTitle: Codex 架构与多端生态图 accDescr: 展示用户通过 CLI、桌面应用、Slack、Teams 或云端访问核心 Codex 代理，并协同各类插件工作的架构。 ``` --- ### [00:05](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=5s) Codex Cloud 的云端环境配置与高效演练在桌面应用中，除了在本地或远程运行任务外，用户现在还可以直接在云端使用 Codex 运行任务。这些云环境既可以由团队预先创建，也可以按需新建。创建新环境时，用户可以自主选择该环境需要访问的不同代码仓库。Dominic 现场选择了 Blossom Music（Holly 之前负责的项目）中的两个项目作为演示。一旦选定仓库，Codex 就会立即着手设置该云环境。它会通过检查代码仓库、依赖项以及完成项目所需的所有准备工作，自动完成以往非常繁琐的手动配置过程。在此过程中，Codex 不仅会自动发现各项依赖，还会编写一个“启动技能（startup skill）”来教导代理如何使用该环境，同时编写一个“启动脚本（startup script）”以确保未来能够对这些环境进行快速迭代。虽然这个 Linux 云环境同时包含了 iOS 和 Web 的依赖项，但它能够准确识别出无法在纯 Linux 环境下运行移动端应用程序，不过这并不影响 Dominic 获取代码并进行引用的初衷。未来，用户还将能够接入自己的自定义云环境，从而在保留 Codex Cloud 强大功能的同时，完全按自己喜欢的方式定制任务运行逻辑。OpenAI 在此投入了大量精力来提升运行速度，其中关键的一点就是对文件系统进行了快照优化，使得后续任务的启动速度大大加快。此外，系统还支持后台自动更新，以确保代码库始终保持最新状态。为了展示 Codex Cloud 的实际应用场景，Dominic 展示了一个此前启动的任务：他将一张在 Figma 中设计好的着色器（shader）界面截图发送到了云端环境。借助已安装的 Figma 插件，Codex 直接从 Figma 中提取了所有必要的细节，成功实现了该着色器，对其进行了测试，并生成了一段演示视频（虽然现场视频加载遇到了一点小插曲）。为了让大家能够亲自体验，他进一步让 Codex 将其转化为了一个可交互的网页游乐场（playground）。这个游乐场直接部署成了在线网站，用户不仅可以在正式部署前在上面测试着色器、调整参数并将设置更新反馈回应用，还能像在本地环境中一样，直接在被编辑的代码行上留下评论、检查代码变更，甚至针对刚执行完的任务开启侧边聊天（side chat）来提出疑问。 - **云环境自动化**：自动检测仓库、分析依赖、编写启动技能与脚本。 - **性能优化**：通过文件系统快照大幅加速后续任务启动，并支持后台自动更新。 - **插件生态联动**：无缝结合 Figma 等插件，自动提取设计稿细节并生成交互式 Playground。 --- ### [00:06](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=6s) 利用 Tailscale 与 OIDC 访问私有资源云环境通常面临的一个痛点是访问私有资源：开发者既希望云环境能够访问某些私有资产，又不想将其完全暴露给公共互联网。例如，Dominic 手头有一个运行在树莓派上的小型 API，该 API 并未对公网开放，仅在树莓派本地运行。为了解决这一安全难题，Dominic 在云环境中配置了 Tailscale VPN 访问权限。通过向环境提供 Tailscale 授权密钥（auth key），Codex 便能安全地访问他 Tailscale 网络上的任何私有资源。与此同时，系统还增加了对 OIDC（OpenID Connect）的支持，方便用户通过 OIDC 访问云端资源。在演示环节中，Dominic 启动了一个任务，要求 Codex 调用运行在树莓派上的 API。为了证明该 API 确实没有运行在公网云端，他展示了 API 运行的特定端口。当未连接时，该端口没有响应；一旦将笔记本电脑连接到同一个 Tailscale 网络，API 就会立刻恢复响应。虽然发布会期间基调演讲出现了一些插曲（可能遇到了短暂的网络波动），但 Dominic 随后展示了备用记录，证明 Codex 能够完美访问仅在 Tailscale 局域网中可用的私有 API 资源。回到最初的设置任务，正如前面所提到的，系统虽然发现无法在 Linux 云环境中测试 iOS 端的变更，但依然能够出色地完成移动端源码的编辑，并给出了实用的安装脚本建议。 ### [10:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=600s) Codex Cloud 环境配置与 Slack 协同调试在配置云端开发环境时，Codex 引入了极具灵活性的“Startup Skill”（启动技能）。开发者既可以手动精细调整配置，也能直接用自然语言向 Codex 提问或下达环境初始化指令。这项机制支持在创建环境时一次性定义完整规范，也允许在后续迭代中随时回溯调整。启动技能清晰罗列了当前项目所需的各项依赖与运行细节，开发者一键确认即可生效。除了基础环境描述，系统还支持精细的网络访问控制、网络密钥（Network Secrets）配置，以及两层环境变量隔离：一种是仅对当前云端环境生效的环境变量，另一种则是存放在个人保险库（Vault）中的个人私有环境变量，后者绝不会泄露给团队其他成员。在可见性方面，环境可以设定为个人专属，亦可一键共享至整个团队。由于所有任务均在云端容器内脱机运行，开发者即便合上笔记本电脑，也能无缝在手机端或浏览器中随时接管与查看运行状态。这种将计算环境完全移至云端的架构，使 Codex 能够直接嵌入团队已有的日常协作平台（例如 Slack）。演讲者现场展示了一段真实的团队协作场景：同事在移动端测试时发现 Web 应用的某些视觉样式实现有误，并在 Slack 频道中发起讨论。演讲者直接在 Slack 中呼叫 `@ChatGPT` 介入排查，模型不仅迅速检索并调出了对应的 GitHub Pull Request，还直接调取了 Figma 设计稿进行像素级对比，当场指出目前已有一个正在处理该问题的 PR。随后，演讲者指令其进一步深入验证并运行测试，Codex 便直接唤醒此前已配置好并共享给团队的云端环境，在隔离容器中跑通全部变更测试。整个排查与修复流程在 Slack 对话流中即时推进，直到 PR 达到可合并与评审的标准。 - **启动技能（Startup Skill）**：支持手动代码修改与自然语言双向交互配置，规范项目的依赖与构建逻辑。 - **双层凭证与网络隔离**：支持配置网络白名单、Network Secrets；区分个人 Vault 私有变量与团队共享云变量。 - **跨平台脱机运行**：计算任务完全脱离本地硬件，合盖休眠后仍可通过移动端或浏览器持续保持会话。 - **Slack 原生协作流**：`@ChatGPT` 可跨工具链直接联动 Figma 设计稿与 GitHub PR，并挂载预设云环境执行实机测试。 --- ### [12:08](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=728s) 桌面端代码审查重构与 Spaces 协同规划随着 AI 智能体自主编写代码的体量呈指数级增长，开发者在编码上的时间被压缩，而代码审查（Code Review）成为了新的时间黑洞。针对这一研发重心的转移，Codex 桌面客户端全面重构了“Code Review”选项卡。开发者现在可以直接在客户端内统一查看所有指派给自己或由自己发起审查的 PR。视图不仅保留了传统的代码差异对比、他人评论查看、行内批注与反馈提交功能，还允许开发者随时调用 Codex 执行全自动代码初审。演讲者强调，最实用的功能在于能够直接在审查面板中向 Codex 追问 PR 的实现细节与架构影响，辅助人类审查者快速洞察改动可能带来的潜在副作用（Side Effects），确认无误后即可一键交付审查意见。与此同时，面对规模更大、跨越数个模块的复杂工程任务，团队规划与多方协同成为了核心瓶颈。“Spaces”正是为此设计的协同载体，它消除了在聊天窗口与外部文档之间繁琐复制粘贴信息的痛苦。演讲者以重构 API 参考实现（API Reference Implementation）及其部署架构为例，演示了完整的协作路径：Codex 首先起草规划草案并沉淀到 Spaces 页面中；随后文档被共享至工程团队收集批注反馈；在此期间，开发者可以持续指令 Codex 细化内容，例如要求其“补充系统架构图以明确组件间的交互关系”，并“插入任务进度跟踪看板”。在执行阶段，负责各项子任务的智能体（Dots 与 Codex 实例）会实时将代码实现进度反哺回该文档中，保持团队全局信息同步。 - **代码审查看板整合**：集中聚合待审与自建 PR，支持行内评论、审查意见流转及 Codex 一键自动审查。 - **副作用智能推演**：支持针对特定 Diff 展开上下文问答，评估边缘情况与架构隐患。 - **Spaces 统一协作中枢**：将规划方案、系统拓扑图与任务追踪器合为一体，避免信息孤岛。 - **多智能体双向同步**：团队所有 Dot 与 Codex 可直接向 Spaces 写入执行状态，文档动态反映工程真实演进。 --- ### [14:42](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=882s) 主动式个人智能体 Dot 与 @ChatGPT 的协作边界针对众多开发者使用循环（Loops）或多层嵌套线程（Threads of Threads）管理任务的习惯，演讲者介绍了具备主动感知能力的个人智能体——“Dot”。Dot 并不单纯等待用户输入 Prompt，而是全天候主动监听产品与工程维度的实时讨论，监控代码库的每一次变更，并在侦测到异常或堵点时主动为开发者创建任务。演讲者分享了一个生活化的趣事：在“周日晚上 10 点 20 分（20 past 10 on a Sunday）”，同事 Carlos 在一个 PR 中 `@` 了他，由于正处于非工作时间，演讲者并未察觉；此时他的专属 Dot 通过 Slack 主动向他发送了提醒通知。由于当时手头没有精力细看，演讲者随手给 Dot 回复了一条语音或简短文本询问 PR 概况，Dot 便迅速消化变更并梳理出提要；在收到“做一次彻底审查”的进一步指令后，Dot 直接在后台为该 PR 启动了一个完整的云端任务，深入代码深处排查潜在 Bug 并回传综合报告，让开发者随时可以在空闲时接手推进合流。为了厘清现场观众的疑惑，演讲者详细剖析了 Slack 场景下 `@ChatGPT` 与“个人 Dot”的定位分野与权限边界：Dot 是开发者本人的数字延伸，在 Slack 中以“开发者姓名 + Dot 标识”命名，深度绑定个人的工作上下文、记忆（Memory）与私人保险库，能够调度开发者的本地 Codex 以及个人专属云环境，适合承担长期跟踪、代理监控与个人任务交接；而 `@ChatGPT` 则是面向团队公域的“共享协同伙伴”，仅拥有团队公开云环境的访问权限，核心职能是作为多位工程师在公共讨论串中集思广益、排查协同 Bug 的公共计算节点。 ```mermaid flowchart TD accTitle: Dot 与 ChatGPT 的架构边界与任务流转 accDescr: 展示个人智能体 Dot 与团队共享 ChatGPT 在权限、环境挂载及任务调度上的协同差异。 subgraph SlackContext["Slack 协作界面"] U["开发者 (个人上下文)"] T["团队成员 (公共讨论串)"] end subgraph AgentLayer["智能体路由层"] DOT["个人智能体 (My Dot) • 绑定个人偏好与工作记忆 • 全天候主动监控频道与变更"] CGPT["@ChatGPT (团队助手) • 公共线程协同讨论 • 多人实时交互"] end subgraph EnvLayer["执行环境与基础设施"] PVault["个人私有资产 • 个人 Vault 保险库 • 本地 Codex CLI"] CloudShared["共享云端环境 (Codex Cloud) • 团队共享容器 • 预设启动技能 (Startup Skill)"] TaskRun["自动触发云端审查任务 (Cloud Tasks)"] end U -->|"指令转发 / 自动化监听"| DOT T -->|"公开 @ 讨论"| CGPT DOT -->|"独占访问"| PVault DOT -->|"调度运行"| TaskRun TaskRun -->|"挂载"| CloudShared CGPT -->|"协同操作"| CloudShared ``` - **全天候主动监控**：Dot 能自主跟踪跨工具讨论与未读代码提议，打破纯被动响应模式。 - **命名与上下文绑定**：Dot 具备强烈的身份认同，绑定个人的工作记忆与开发风格，公开标明从属关系。 - **权限与环境隔离策略**：Dot 贯通本地 Codex 与私有云资产；`@ChatGPT` 严格受限于团队共享云环境，保障私密凭证安全。 --- ### [17:16](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=1036s) CLI 终端重构与 Web 端全能体验对于习惯终端命令行工作流的重度开发者，Codex 对 CLI 进行了全面重构。新版 CLI 引入了专属的“Agent View”（智能体视图），允许开发者在单终端窗口内纵览当前所有由 Codex 并行跑动的任务进程，清晰掌控哪些任务需要人工干预、哪些正在后台编译，并支持高并发启动与切换任务。此外，CLI 的底层体验得到大幅优化：新增针对各类插件的 `@` 补全语法、大幅提升终端文本选区的响应速度，并原生支持在终端内直接渲染复杂图表与 LaTeX 数学公式。CLI 还整合了此前桌面端饱受好评的“Voice Mode”（语音模式），接入了相同的 GPT Live 低延迟实时语音模型，让开发者可以直接对着终端与智能体展开自然对话（尽管现场演示时麦克风突发未启用的小故障，引来观众善意的笑声）。与此同时，Codex 正式将其完整能力扩展至 Web 浏览器（Chrome）。开发者无需在本地机器上下载或配置任何客户端，即可获得与桌面端高度一致的交互体验。在 Web 端，用户可以自由调阅 Codex Cloud 托管的所有云端任务流水线，查看实时生成的应用快照（App Snapshot）、回放此前执行过程中捕获的操作录屏，甚至能够直接在网页内嵌窗口中与刚刚部署上线的临时站点展开交互。此外，Web 端同样支持连接个人 Dot 智能体，而“Code Review”选项卡也计划在数日内上线 Web 端，从而彻底摆脱对本地软硬件环境的依赖。 - **CLI 智能体视图（Agent View）**：在终端提供多任务监控大盘，支持多 Agent 并行吞吐与状态干预。 - **终端富文本与公式渲染**：原生解析显示终端架构图与 LaTeX 公式，支持插件快速 `@` 补全。 - **终端原生实时语音**：集成 GPT Live 语音模型，允许通过口语直接驱动命令行智能体。 - **Web 端体验对齐**：支持浏览器端预览部署站点、查看交互录屏回放，并即将集成代码审查全功能。 --- ### [19:48](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=1188s) 研发范式演进与三大工作流建议演讲进入尾声，演讲者回顾了过去一年软件工程范式的深刻巨变：研发人员与 AI 的交互方式已经彻底越过了“单点代码片段生成（Individual Tasks）”的初级阶段，全面迈向“将整套高维目标与宏大问题托付给 Agent”的新纪元。这种转变赋予了单兵开发者极强的交付能力，使他们能够将脑海中的复杂构想直接转化为高质量的工业级生产系统，而不再仅仅止步于粗糙的原型玩具（Prototypes）。演讲者坦言，团队并不期望开发者在一夜之间颠覆现有习惯并全面生搬硬套所有新工具，但他极力推荐每位开发者尝试以下三种最具杠杆效应的工作流转变： > “过去这一年，我们的开发模式发生了翻天覆地的变化——从委派单个零散任务，转变为将越来越庞大、复杂的宏观目标托付给我们的智能体。” 1. **全面转向 Codex Cloud，告别本地“开盖待机”与繁重的 Dev Box 运维**：如果开发者仍在用“笔记本合不上盖子以免后台任务中断”的方式工作，或在本地维护着一堆环境各异的虚拟机与容器，应果断尝试 Codex Cloud。借助标准化、即开即用的云端预置环境，极大降低本地机器负载与基础设施维护成本。 2. **使用 Spaces 建立统一的“人机协作中枢”，终结信息剪贴地狱**：如果开发者厌倦了在团队文档与 AI 聊天框之间反复横跳、手动复制粘贴需求与执行方案，应当启用 Spaces。将功能方案、拓扑图与任务看板集中于一处，让 Codex 与 Dot 在编码推进的同时自动回写最新进度，确保人类团队与智能体之间时刻信息同频。 3. **赋予个人 Dot 持续性职责，摆脱逐次手动 Prompt 催促**：如果开发者对一遍遍手动向 Codex 输入 Prompt、逐个步骤指令确认感到疲惫，应尝试将一项长期性、持续性的职责（Ongoing Responsibility）全权授权给自己的专属 Dot。让智能体主动承担起监控、跟踪、推进任务闭环的责任，推动工程车轮持续向前滚动。演讲在热烈的掌声中结束，演讲者鼓励所有开发者借助摆脱了物理笔记本限制的 Codex，在任何平台、任何设备上将长久以来的技术构想变为现实。 ## Notable quotes > [00:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=0s) 委派工作应该像告诉 Codex 去做某事一样轻松，而不应让用户为采购电脑操心。 — Dominic > [00:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=0s) 用户应当能够在自己选择的任何界面上使用 Codex 运行框架，并自主决定任务在何处执行，从而根据自身需求灵活调整工作流。 — Dominic > [00:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=0s) 所有这些新产品都运行在大家熟悉的核心 Codex 代理之上，这意味着用户可以通过账户中已安装的插件继续访问相同的工具和信息，而无需从头开始配置。 — Dominic > [10:00](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=600s) 启动技能清晰罗列了当前项目所需的各项依赖与运行细节，开发者一键确认即可生效。 — Dominic > [12:08](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=728s) 最实用的功能在于能够直接在审查面板中向 Codex 追问 PR 的实现细节与架构影响，辅助人类审查者快速洞察改动可能带来的潜在副作用（Side Effects），确认无误后即可一键交付审查意见。 — Dominic > [14:42](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=882s) Dot 并不单纯等待用户输入 Prompt，而是全天候主动监听产品与工程维度的实时讨论，监控代码库的每一次变更，并在侦测到异常或堵点时主动为开发者创建任务。 — Dominic > [14:42](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=882s) Dot 是开发者本人的数字延伸，在 Slack 中以“开发者姓名 + Dot 标识”命名，深度绑定个人的工作上下文、记忆（Memory）与私人保险库，能够调度开发者的本地 Codex 以及个人专属云环境，适合承担长期跟踪、代理监控与个人任务交接；而 @ChatGPT 则是面向团队公域的“共享协同伙伴”，仅拥有团队公开云环境的访问权限，核心职能是作为多位工程师在公共讨论串中集思广益、排查协同 Bug 的公共计算节点。 — Dominic > [19:48](https://www.youtube.com/watch?v=XkKdbPhIvbY&t=1188s) 过去这一年，我们的开发模式发生了翻天覆地的变化——从委派单个零散任务，转变为将越来越庞大、复杂的宏观目标托付给我们的智能体。 — Dominic ## Mentioned Dominic, Sam, Peter, Holly, Carlos, OpenAI, Codex, Codex Cloud, Codex CLI, Codex Desktop App, Dots, Dot, ChatGPT, Blossom Music, Slack, Microsoft Teams, Figma, Tailscale, OIDC, GitHub, Raspberry Pi, Mac mini, Linux, iOS, Spaces, Google Chrome, GPT Live ## Video description Explore what’s new in Codex across the CLI, app, and web. Through live demos, see how to move from delegating individual tasks to letting Codex tackle entire problems and goals. [Source](https://www.youtube.com/watch?v=XkKdbPhIvbY)

Source quotes

[0:00] Dominic: 委派工作应该像告诉 Codex 去做某事一样轻松，而不应让用户为采购电脑操心。 [0:00] Dominic: 用户应当能够在自己选择的任何界面上使用 Codex 运行框架，并自主决定任务在何处执行，从而根据自身需求灵活调整工作流。 [0:00] Dominic: 所有这些新产品都运行在大家熟悉的核心 Codex 代理之上，这意味着用户可以通过账户中已安装的插件继续访问相同的工具和信息，而无需从头开始配置。 [10:00] Dominic: 启动技能清晰罗列了当前项目所需的各项依赖与运行细节，开发者一键确认即可生效。 [12:08] Dominic: 最实用的功能在于能够直接在审查面板中向 Codex 追问 PR 的实现细节与架构影响，辅助人类审查者快速洞察改动可能带来的潜在副作用（Side Effects），确认无误后即可一键交付审查意见。 [14:42] Dominic: Dot 并不单纯等待用户输入 Prompt，而是全天候主动监听产品与工程维度的实时讨论，监控代码库的每一次变更，并在侦测到异常或堵点时主动为开发者创建任务。 [14:42] Dominic: Dot 是开发者本人的数字延伸，在 Slack 中以“开发者姓名 + Dot 标识”命名，深度绑定个人的工作上下文、记忆（Memory）与私人保险库，能够调度开发者的本地 Codex 以及个人专属云环境，适合承担长期跟踪、代理监控与个人任务交接；而 @ChatGPT 则是面向团队公域的“共享协同伙伴”，仅拥有团队公开云环境的访问权限，核心职能是作为多位工程师在公共讨论串中集思广益、排查协同 Bug 的公共计算节点。 [19:48] Dominic: 过去这一年，我们的开发模式发生了翻天覆地的变化——从委派单个零散任务，转变为将越来越庞大、复杂的宏观目标托付给我们的智能体。

Source quotes

[0:00] Dominic: delegating work should be as easy as just telling Codex to do something, and it picks up the work regardless of whether you have to go and procure more computers. [8:00] Dominic: You might have noticed we had some outages during the keynote. There's some working on it [19:55] Dominic: If you're still leaving your laptop cracked or managing a pile of dev boxes in whatever shape it is, try out Codex Cloud for your work.

Original transcript

[0:00] *music* Thank you. Hi everyone, my name is Dominic, I work on developer experience here at OpenAI. Now, Sam earlier launched around 20 or so new features. And between those and the roughly 300 features that we launched over the course, of the last year. that Building with them has drastically changed how we build things at OpenAI and how many of you build. Thank you. And I know this is incredibly hard to keep up. So over the next 25 minutes, I want to give you some practical examples how you can actually incorporate these things into your workflows. Because... The fact is, these features have drastically changed how we build, and I believe they're going to change how you build. But I also know that it can be not just overwhelming but confusing how to actually build these things into your workflow. And ultimately, I want you to build how And ultimately, I want to make sure that you can use codecs anywhere the way that you want to. At the beginning of the year, I don't know about you all, but for me, it was pretty common to run one or two tasks But seeing Peter have this tweed with like... I don't know, 40 different Codex is running at the same time. It felt overwhelming. I could not imagine actually running that many tasks at the same time. But then we launched the Codex app, and it made delegating and switching tasks so much And since then, running multiple agents at the same time is almost the norm. And as models got better and more capable, especially around computer use and long-running work, we started handing increasingly more... increasingly bigger problems after the models, often running for hours or days. And as a result, we started carrying our laptops half open just to keep them running between meetings. And to solve that, I don't know about you all, but how many of you ended up buying a Mac mini or a Raspberry Pi or even renting some VPSs just to keep your agents running. But more machines means that you have to deal with more upkeep, more disk space, dealing with updates, overall capacity that you need to manage, and every time you want to do more, you have to procure more. But delegating work should be as easy as just telling Codex to do something, and it picks up the work regardless of whether you have to go and procure more computers. Because ultimately you should be able to use the codex harness in whichever interface you and choose where that work runs for you. So that you have the opportunity to adapt the workflow to to adapt the workflow to your needs, and as agents and models become more capable, continue to keep up with that. And so today we launched Codex Cloud, Dots, and AdChat GPT in Slack and in Teams. And all of these use the same codex agent that you've been using. meaning you have access to the same tools and information through the plugins that you already installed in your account, And it means that you can pick the features that fit your workflow without having to start from scratch. Enough talk though, let's actually show you a couple of these things and how you can use Thank you. All right, so in the desktop app, additionally to running tasks locally, or running them on your remote, you can now run tasks on codecs in the cloud, using environments that either your team has already created or by creating a new environment. When you create a new environment, you can pick the different repositories that you want the environment to have access to. We're going to pick two of the projects from Blossom Music, the project that Holly was working on. As soon as I select these, Codex is actually going to begin to work on setting up this It will do all the preparation for you by inspecting the repository, the dependencies, and set up all of the necessary things that might be required to work on this project. This used to take a lot of manual configuration and was often very cumbersome. As part of this, it will not just discover the dependencies, it will also ride both a startup skill that teaches the agent how to use the environment, And it will write a startup script to make sure that it can quickly iterate on these environments. In this case, If everything goes well, it will never... [5:00] This-- we have-- iOS and web dependencies in here both at the same time. However, because this is a Linux environment, you can see here, It is noticing correctly that it won't be able to run the mobile application. which is fine for me because in this case, I just wanted to have access to that code so I can reference that. However, Eventually, you'll be able to bring your own cloud environments, which means that you can actually adapt this to whatever way you want these tasks to run. while still leveraging the same capabilities of Codex Cloud. One of the things that we did put a lot of effort in as part of this is making sure that things run faster than before. which means that we put a lot of effort into the snapshotting of the file system, making subsequent tasks faster to start up. but it also means that we can run background updates to make sure it has the latest repo changes and run any other update scripts necessary. Now, I'm going to let this run for a bit, but I wanted to show you an example of what you can do with Codex Cloud. So in this case, Um... I kicked off a task earlier where I send in an app shot to go and implement a shader that we had designed in Figma. So I took an app shot like this. and send it over to my cloud environment. And from here, it worked on it, pulling all of the necessary details directly from Figma using the Figma plugin that I had installed in my account. From here it went and actually implemented the-- The shader, it tested it and created a video that for some reason It's not loading right now. But in order to actually play with it, and because we have access to all of the different plugins in our environment. I went ahead and actually asked it to turn the same thing into a little playground that we can play with. So this is deployed as a site, and from here, I'm able to test out the shader. before I actually deploy it to the site itself. I can tweak things and then I can go and send off any additional updates. to the settings back to my app. I can also, the same way that I'm used to from any other local environment that I might Codex and before. Use the app to leave comments directly on the code that was edited. Inspect what has changed. And even... Start up a side chat if I want to have questions about the task that was just executed. The other thing that is normally a common drawback with cloud environments-- is access to private resources. You might have some resources where you want to be able to have the cloud environment access those, but not expose them to the entire public Internet. One of those examples is I have this little API running on this Raspberry Pi right now. It is not available to the internet. It runs on this Raspberry Pi alone. But I configured my environment here to be able to use Tailscale as a VPN access. So I gave it access-- thank you. I gave it an off key to my tail scale, and from here, Codex can access any of my resources on my tailscale network. At the same time, we also added OIDC support, so if you want to access your cloud resources through OIDC, you can do that as well. And so I have an environment here that we can start off a task and I can ask it to pull the API that is running on this task And to prove to you that this is actually an API that doesn't run on the cloud. This is the port that the API runs on. Right now it's not responding, but if I connect my laptop to that same tail scale network, See? All right? We can see the APIs responding. And so if we're going back, to the task. Seems something. You might have noticed we had some outages during the keynote. There's some working on it. So I don't know exactly what's going on here, but I'm going to show you a backup. So here you can see I asked this earlier. And we're doing the same API calls in this request. We're doing the same API calls here so Codex is able to access those same resources that are just available in our tail scale network. All right, let's take a look at how our setup task went here. So, as I mentioned earlier, it figured out that it cannot actually test the iOS changes, but that it can still do mobile source editing, and then it suggested to us here, both an install script that we can run as well as a [10:00] Startup skill. From here I can go and modify this by hand or I can continue to ask Codex any questions or give it instructions about how I want to continue to configure this environment. You can do that while you're creating it the first time or continue to come back and iterate on it further. And similarly, we have a startup skill that describes all of the necessary details here for this project. And I can go and accept these. And I can do any other changes like controlling what network access it has. set up the network secrets, and even configure environment variables that are either specific to the cloud environment that I have. or use personal environment variables that are stored in my vault so that they're not shared with my team. Because the other thing that I can do is choose between sharing... this environment, with just myself or with my entire team. And because these tasks run in the clouds, I can actually turn, like, close my laptop and continue to have access to all of those tasks on my phone, or in the browser. The other thing that you get out of running these tasks in the cloud is that we can bring them into the environments where our teams are already working. So in our case, that's Slack. Thank you. where we were able to have a conversation between me and my colleague about this bug that he found in the app where it looked like the web app didn't actually have the right visuals implemented. I asked ChatGPT, to go and figure this out. It actually pulled up the pull request. It also accessed the Figma files. to figure out what was wrong. And notice that there was already a PR that was solving this problem. I asked it to dive deeper into it and even test these changes, and it used that same cloud environment that I had already created. and share it with my organization. to test all of the changes. We were able to collaborate on this between both of us and ultimately get to a point where the PR is ready to be reviewed. Talking about reviewing code, I don't know about you all, but as agents write more code, I find myself spending more time actually reviewing code. And because of that, we ended up overhauling the code review tab inside the desktop app. So you can now see all of the PRs that are assigned to both yourself or were created by you directly in the app. And from here, you can do all the things that you would do with a regular... Code review, you can see the code, you can leave comments, you can see the comments of others. Submit your review feedback. or even run a review with codecs, The thing that I personally find incredibly helpful though, is to be able to ask questions directly inside the app. Come on. Directly within the app. There we go. To get details about what this PR is about and help myself better understand the side effects that might be happening inside this particular pull request. And when I'm happy, I can submit the feedback. As agents take on bigger work, the other big part is planning and collaborating with our Um. Space is a great way for you to actually collaborate both with your agent and with your team at the same time without having to copy/paste different pieces of information back and forth. So in this case, I was working on a redesign of our API Reference implementation. and how I want to deploy it. And so in this case, Codex wrote up a plan. I put it into space. I can share it with my team. get feedback from them, But I can also continue to iterate with codex on it. So in this case, I asked it to add a system diagram to better understand how these different pieces fit together. and then have a task tracker as well. And as Codex works on these tasks, I can have it update those, or if I'm working with the entire team on this project, we can have all of our-- DOTS and our codecs contribute to this document so that we're all in sync on what is happening. The other thing that I can do is, once I'm happy with this plan, I can go and ask Codex to implement the-- plan and it will pick it up and continuously push information back if I wanted to. The last part of all of this is proactivity. Yeah. How many of you have been using loops or threads of threads to manage their work? A decent amount of you. So you will actually love the productivity of dots because it gives you a way for you to manage both your existing codex tasks and hand off more tasks to codex while gaining some productivity of dots continuously watching out on what is happening. That means you can track product and engineering discussions, it can notice [15:00] code changes for you. And then it can also spin up tasks for you where necessary. In this case, for example, my colleague, Caralus, had tagged me in a PR that I had missed. And I got a notification in Slack from my dot to check out this PR. I didn't really have time in this moment to take a look at it. It was 20 past 10 on a Sunday. So I asked what the PR was about, and my dad actually started reviewing that PR, trying to figure out what it was about. and then I asked her to do a more thorough review. As part of this, It went ahead and actually spun up a full-on cloud task directly from my Slack environment so that it could dive into the PR, figure out what the issues are, and then report back to me. But because this is an actual task, I can also go in here and continue to ask follow-up questions myself later on. or even use this to bring the PR over the finish line. Now, I showed you two Slack examples, and one of the questions I'm certain you're asking yourself right now is, great, there is @ChatGPT, and there is my . when do I use which, and what's the difference? And the way to think about it is the dots are an extension of yourself. We intentionally named these with your name and then the name of your dot so that people inside Slack understand that they're tied to your personality, they have context about What you're working on your memory? And so they're great for any ongoing work that is related to what you do. That means my dot regularly watches channels that I care about, weighs in on topics if I give it the permission to. But it also just means that I can forward-- constantly forward tasks to it in Slack or in other channels to go and have my dot tackle tasks for me. HHGPT, on the other hand, is meant for collaboration. It's a great way for you and your colleague to work in a thread at the same time, interact on it. work together on a PR, for example, and because of that, your DOT has access to all of your cloud environments and your local codecs. while AdChat GPT only has access to your shared cloud environments. but it makes it so much easier for you to collaborate on things. Now, earlier I mentioned that I want you to be able to use codecs anywhere you want to, in whatever way you want. And so far, the only thing that I showed you is desktop and we talked about mobile. But I know a lot of you also love using the CLI, and because of that, We started giving the CLI a big overhaul. Among other things, you now have an agent view, which means you can see all of the different tasks that are running inside your codecs. So you can keep an eye on which ones need your attention, start up new ones, and run multiple ones in parallel very Thank you. We've also overhauled We also overhaul things like being able to @mention both all of your plugins that you're as well as making it significantly faster to do things like selecting text, You can render-- diagrams and latte directly inside the terminal. And we even added things like voice mode so that you can now talk to your agent directly within the terminal using the same Um... The microphone is not enabled on this one. But using the same GPT Live model that you know and love from the desktop app. The other thing that you can do now is use more of your experience directly in the web. So this is Chrome. It is not the desktop app, but you're going to see a very familiar experience. You can access all of your cloud tests that you've been running using Codex Cloud. directly in the browser. You can see here actually it shows the same app shot that I sent over. We can review that video that wasn't playing earlier. So you can see it here, engaging with it. And you can even interact with the sites that were deployed directly within your web interface. You can also access your dot and soon hopefully very soon in the next coming days, you'll be able to access your code review tab inside the web app as well. So you don't have to install or use the desktop app. just to get more things done. Okay. Now, the way we develop has drastically changed over the last year. Right. [20:00] from individual tasks to giving increasingly bigger and bigger problems to our agents. And it made it easier for you to take on the things that you've dreamed up and actually build high-quality solutions. rather than just some prototypes. And you don't need to adopt all of these things that I've showed you today all at once. We want you to be able to use Codex wherever you want and however it fits into your workflow. But there are three things I would encourage you to try. One, if you're still leaving your laptop cracked or managing a pile of dev boxes in whatever shape it is. Try out Codex Cloud for your work. It means you can move off your laptop and reuse prepared environments and spend less time maintaining that infrastructure. And if you're tired of jumping across docks for your team, And then go and copy the plan back into a doc for codex to be used. Instead, try out space. It gives you the ability to take the features and plans and keep them in one place for both your agents and for your team. And it lets your codecs continuously update the progress directly within the dock. said your team knows what is happening at the same time. And if you're tired of manually forwarding work to codecs and prompting each every time, prompting it every time. Give your dot an ongoing responsibility that you're handling. and let it keep track of that work, and let it handle keeping it moving. With that, go ahead and build the things that you've been dreaming up with Codex anywhere. Thank you. Bye. .