OpenAI Shifts Codex to Cloud Agents to Fix Developer Bottlenecks

From Single Player to Multiplayer with Codex | DevDay 2026 — OpenAI

OpenAI

Single-player AI tools turn individual engineers into operational bottlenecks, requiring persistent cloud agents and shared workspaces to coordinate tasks across entire teams.

AI-assisted summary of From Single Player to Multiplayer with Codex | DevDay 2026 — original source. Check the original for full context.

Source published:

Key ideas

  • OpenAI highlights an operational shift from 'super-powered ICs' to multiplayer systems, warning that hyper-productive solo engineers using local AI tools quickly turn into organizational bottlenecks. (0:00)
  • AppShots account for approximately 30% of the presenter's Codex sessions, capturing application metadata, active URLs, and below-the-fold content rather than simple static screenshots. (5:04)
  • Cloud-native persistent agents operate in independent sandboxes with dedicated browsers and files, maintaining tethered local access to execute privileged tasks on an engineer's machine when approved. (6:17)
  • OpenAI's internal workflows utilize collaborative Spaces governed by page instructions (.agent-md) and WebMCP interfaces, enabling multiple human and agent contributors to write to a single source of truth. (13:00)

Detailed notes

## Background Published on YouTube by OpenAI on October 7, 2026, this DevDay presentation walks through a 2:00 AM outage investigation from the initial Slack alert to a fully reviewed fix. The video demonstrates how voice interfaces, AppShots, plugins, and collaborative meeting notes empower a persistent personal agent to troubleshoot technical issues while keeping cross-functional teams aligned.

## TL;DR Jason from OpenAI's Developer Experience team charts the transition from being a solo, high-friction bottleneck to deploying persistent, 'multiplayer' AI agents like Dot. While early single-player workflows relied on manual prompts and individual AppShots, modern systems combine cloud sandboxes, agentic voice, and hybrid local execution to pursue long-running investigations autonomously. Shared context is maintained via collaborative Spaces, page instructions, and standardized plugins rather than isolated chat threads. Ultimately, automating rote digital maintenance prevents developers from getting trapped in late-night coding silos and restores focus to creative, team-wide problem solving.

## Atmosphere & style The presentation carries a candid, conversational, and deeply relatable tone as Jason builds an immediate rapport with the audience by recalling sitting in their seats just a year prior. It feels like an authentic reflection on developer burnout and the trap of solo hyper-productivity, balancing self-deprecating humor about frantic late-night triage with an earnest, energizing vision for collaborative engineering. Watching the talk evokes the relief of unburdening operational stress, transforming an isolated coding grind into a social, creative team effort.

## Bulletin - [00:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=0s) OpenAI highlights an operational shift from 'super-powered ICs' to multiplayer systems, warning that hyper-productive solo engineers using local AI tools quickly turn into organizational bottlenecks. - [05:04](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=304s) AppShots account for approximately 30% of the presenter's Codex sessions, capturing application metadata, active URLs, and below-the-fold content rather than simple static screenshots. - [06:17](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=377s) Cloud-native persistent agents operate in independent sandboxes with dedicated browsers and files, maintaining tethered local access to execute privileged tasks on an engineer's machine when approved. - [13:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=780s) OpenAI's internal workflows utilize collaborative Spaces governed by page instructions (.agent-md) and WebMCP interfaces, enabling multiple human and agent contributors to write to a single source of truth.

## Key takeaways - [00:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=0s) Optimizing purely for individual contributor productivity turns engineers into micromanagement bottlenecks across fragmented tools and workflows. - [00:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=0s) True multiplayer AI does not mean dumping teammates into a shared chat window, but synchronizing cross-functional state across autonomous background systems. - [02:08](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=128s) Incident response evolved from manual local Codex scripts to siloed heartbeats, and ultimately to persistent cloud agents monitoring Slack, email, and trackers. - [05:04](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=304s) AppShots bridge context gaps by capturing rich application DOM state, URLs, and off-screen content directly from active desktop applications. - [05:04](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=304s) Relying strictly on manual screen captures and local automation hits a ceiling defined by personal actions per minute (APM). - [06:17](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=377s) Persistent cloud sandboxes let agents continue long-running investigations without draining local machine battery or stopping when laptops close. - [06:17](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=377s) A hybrid permission bridge allows cloud agents to request elevated access and execute last-mile verifications inside local authenticated browser sessions. - [06:17](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=377s) Agentic voice transitions speech input from one-way dictation into dynamic, two-way reasoning and real-time clarifying questions. - [10:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=600s) Unstructured, chaotic audio rambling from live team meetings can be transcribed into actionable background tasks and pull requests by persistent agents. - [10:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=600s) Embodied agent handles such as @jason.dot allow team members to delegate and route tasks directly inside Slack or Teams. - [13:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=780s) Transitioning from isolated local context vaults to cloud-based Spaces creates a single source of truth accessible by both humans and autonomous agents. - [13:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=780s) Page instructions modeled on .agent-md files prevent multi-agent collaboration from causing layout drift and formatting conflicts. - [17:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=1020s) Engineers are encouraged to become the 'plugin hero' of their organization by packaging workflows into versioned plugins, auth connectors, and WebMCP interfaces. - [20:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=1200s) Ambient agent listening and proactive background execution turn offhand Slack and voice brainstorms into functional web prototypes and slide decks. - [21:23](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=1283s) Offloading digital chores to background agents helps engineers escape the isolated 'coding cave' and re-engages collaborative human teamwork.

## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=0s) From Super-Powered Bottleneck to Multiplayer AI

Jason from OpenAI’s Developer Experience team opens by taking in the audience, laughing that after sitting in those very seats just a year prior, standing on stage feels surreal. Seven months into his role at OpenAI shipping features at breakneck speed, he found himself confronting an unexpected wall. As tools made him dramatically more productive, he realized he had turned into the "glue for all these systems"—and ironically, the single biggest bottleneck for everything he touched. Asking the crowd for a show of hands on who else feels overwhelmed micromanaging their tools, he is met with a sea of nodding heads and raised hands. The early era of AI assistance focused entirely on what an individual could do, quickly progressing into giving models direct access to computer screens, files, and browsers. But scaling the individual contributor only went so far.

The real breakthrough lies in shifting the paradigm from the "super-powered IC" to collaborative systems that bring the entire team along. Recent innovations like computer use, voice, and cloud sandboxes still largely optimized for solo operators. With environments like Dot and Space—equipped with page instructions, team automations, and plugin extensions—the objective has transformed into setting up team-wide success. Jason clarifies that "multiplayer" does not simply mean dumping coworkers into a shared chat thread. Instead, it is an operating model where no single person has to carry an investigation or task to the finish line alone. Conversations happening naturally among teammates are picked up automatically, state is synchronized, and agents handle tracking while leaning on humans for key decisions.

- Jason joined OpenAI's Developer Experience team seven months prior, transitioning from an audience member the previous year to a DevDay presenter. - True multiplayer workflows mean background systems maintain cross-functional state across teammates rather than routing all execution through a single person's chat window.

---

[02:08](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=128s) The Evolution of Incident Response: From Manual Glue to Shared Workflows

To illustrate the multiplayer shift, Jason sets up a hypothetical 8:00 AM scenario: scrolling Twitter and spotting customer chatter about usage limits and rate limit errors. Even without knowing what broke or whether another engineer has started looking, the issue requires immediate triage, escalation, and tracking so context does not vanish inside a Slack thread or browser tab.

Jason contrasts how handling this scenario evolved over the preceding months:

```mermaid flowchart TD accTitle: Evolution of Incident Workflow accDescr: Three-stage timeline showing the evolution from manual local scripts to single-player automations to unified multiplayer agents.

subgraph SixMonthsAgo["6 Months Ago (Single-Player Manual)"] M1["Local Codex runs on laptop"] --> M2["Manual Slack checking & glue work"] M2 --> M3["Human acts as single point of failure"] end

subgraph ThreeMonthsAgo["3 Months Ago (Siloed Automations)"] T1["Pinned threads & scheduled heartbeats"] --> T2["Duplicate tasks across siloed teams"] T2 --> T3["Engineer becomes half-PM / half-support"] end

subgraph Present["Present Day (Multiplayer with Dot)"] P1["Dot ingests Slack, browser, email"] --> P2["Proactive tracking across teams"] P2 --> P3["Shared skills, plugins & extensions"] end

SixMonthsAgo --> ThreeMonthsAgo --> Present ```

Six months prior, this process was completely manual. Jason would run Codex locally on his machine, prompt it to scrape through Slack, and manually piece together fragments of information. Three months prior, automated task runs improved things by allowing him to pin threads and set heartbeat automations, but coworkers still could not pick up where his local agent left off. He found himself acting as "half a PM and also customer support," only to discover adjacent teams were running the exact same queries and duplicating effort.

In the current multiplayer workflow, persistent agents like Dot monitor Slack threads, incoming emails, and tracker updates without human micromanagement. Instead of setting up fifteen fragile heartbeat automations and unmaintained Markdown memory vaults, the agent follows the investigation autonomously, keeping engineers and customers in sync. Over time, these shared workflows crystallize into team plugins, skills, and extensions rather than throwing brute-force tokens at individual prompts. Jason outlines his framework for the talk around three core acts: capturing context, organizing and driving work forward, and sharing capabilities across the organization.

---

[05:04](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=304s) AppShots: Meeting the Agent Where You Work

Diving into Act 1—gathering context—Jason highlights AppShots as a primary tool for feeding situational awareness into ChatGPT and Codex. Triggered by a quick keyboard shortcut on either side of the space bar, an AppShot captures far more than a visual screenshot: it ingests the application's underlying metadata, active URLs, and all off-screen content below the fold. For Jason, AppShots bridged the gap between his active workspace and his agent, accounting for roughly 30% of all sessions he initiated in Codex. Instead of opening a blank composer and typing instructions to inspect a browser or read Slack, AppShots allow the user to tag the assistant directly inside the app they are using.

Yet relying exclusively on AppShots exposed the ceiling of single-player workflows. Jason jokes that he became one of the "top three like AppShot users of all time," yet still found himself grinding until 2:00 or 3:00 AM. He remained the primary bottleneck because he had to capture every frame, pin every thread, manage two-hour timer intervals, and manually update the agent after meetings. He realized he was hard-capped by his personal "APM" (actions per minute), acting merely as a hyper-efficient micromanager for a collection of disconnected tasks.

- AppShots ingest rich application state—including metadata, DOM/URL context, and below-the-fold content—rather than raw image pixels alone. - Approximately 30% of Jason's Codex sessions originated directly from an AppShot trigger. - Scaling personal APM through manual triggers creates an operational ceiling, turning the engineer into a coordinator rather than eliminating manual overhead.

---

[06:17](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=377s) Embodied Cloud Agents and Agentic Voice

The transition from solo micromanagement to true leverage hinges on agents that are persistent, proactive, and embodied. Thanks to core research advances in memory compaction and long-running context, tools like Dot operate persistently in the cloud. When an AppShot is captured from a laptop, the context is handed off to Dot, which provisions its own independent cloud environment equipped with a dedicated browser, files, and computer. As a result, incident investigations continue uninterrupted whether the engineer’s laptop is asleep, closed, or offline.

At the same time, cloud agents maintain a tether back to local machines when elevated privileges are required—a setup Jason calls "remote control on steroids." If an investigation launched in the cloud requires an authenticated browser session, an internal tool, or a locally running app on the engineer's laptop, Dot can ping the user on their phone and request permission to execute the last mile of work directly on their physical machine.

Alongside persistent environments, input modalities have shifted from one-way dictation to bidirectional "agentic voice." While standard dictation speeds up prompting because people naturally speak three to four times faster than they type, agentic voice establishes a dynamic back-and-forth dialogue across desktop and mobile. The agent executes research in the background, surfaces verbal status updates, asks clarifying questions, and brainstorms solutions in real time. Jason reflects that this fluid, proactive collaboration marks the first moment where working alongside an agent makes an engineer genuinely "feel like a superhero" and heralds "another wave of AGI."

- Cloud-native execution allows Dot to investigate issues in independent sandboxes with dedicated files and browsers without draining local machine resources. - Local permissions provide a hybrid bridge, letting cloud agents execute local verifications or access active browser sessions when granted access. - Agentic voice replaces one-directional speech-to-text with two-way interactive reasoning, background task execution, and proactive question-and-answer exchanges.

[10:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=600s) Multidirectional Voice Context and Agent Embodiment

Working with AI transitions from a solitary loop into a shared, multidirectional collaboration during live meetings. When talking to coworkers, those spoken conversations are automatically transcribed and surfaced to Dot in the background. While Dot isn't quite ready to join audio calls directly and chime into conversations unprompted—"Maybe we'll get there one day"—having an agent continuously capture audio prompts transforms collaboration. The greatest power of voice is the freedom to be chaotic: you can ramble, mention vague hunches, and let the background agent sort through the clutter. During an actual outage call, a frantic brainstorm sounded like: "I think it might be guardian mode. I think I saw a Slack message from a guy whose first name starts with T. Can you also check the configuration for the feature flags, caching updates, and also compare some pull requests?" Without voice-driven persistence, an engineer would simply snap a static Appshot, type a basic "please investigate", and get frustrated when the model failed due to lack of depth.

```mermaid flowchart TD accTitle: Real-Time Meeting Voice Flow to Agents accDescr: Captures unstructured meeting discussions and transforms them into structured agent background tasks.

subgraph AudioCapture["Meeting Audio Ingestion"] A["Team Voice Conversation"] --> B["Automatic Transcription"] B --> C["Dot Agent in Background"] end

subgraph ActionExecution["Background Actions"] C --> D["Slack Connector: Message Teammates"] C --> E["Browser Connector: Scrape Feedback IDs"] C --> F["Draft Docs & Timelines"] end ```

Transcribing meetings is not inherently novel, but having a proactive, persistent agent that turns conversations into actions changes the dynamic. If an intriguing concept pops up during a discussion, it can be prompted on the fly: "Oh, that's a good idea. Let's turn it into a blog post. Please go draft something that we can review later." At the end of calls, Dot accepts its own punch list alongside human action items, using the Slack connector to check comprehension with teammates, routing updates to primary channels, or driving the browser to collect customer feedback IDs. Outside of formal meetings, embodiment takes shape in chat platforms like Slack or Microsoft Teams. Teammates can invoke agents as discrete entities with their own handles, such as `@jason.dot`, allowing users to assign tasks across personal dots and future dedicated team dots.

- Spoken rambling replaces the friction of manual note-taking and manual prompt formatting. - Dot operates with proactive persistence, running jobs asynchronously across tools rather than requiring continuous manual Appshots. - Agents act across multiple environments via dedicated tool connectors (Slack, browser automation, document editors). - Embodied agent handles enable users to delegate issues collaboratively in group channels: "And all of a sudden, I feel like the CEO who's just tagging people left and right."

[13:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=780s) Migrating from Local Vaults to Collaborative Spaces

Relying purely on local automations created an operational bottleneck: while local setups worked for solo flows, teammates could not contribute, and modern cloud-based agents were cut off from the local machine. Software engineering advanced because developers collaborated against a single source of truth, yet knowledge work has historically lacked that equivalent shared medium. By transitioning local context vaults into a cloud-based Space, teams gain a shared workspace where both humans and agents read and write from identical state templates.

```mermaid flowchart LR accTitle: Collaborative Space Architecture accDescr: Shows how instructions and multiple agents align around a unified Space document.

subgraph SpaceContext["Cloud Space (Single Source of Truth)"] SD["Document / Page"] INST["Page Instructions (.agent-md)"] INST -.->|"Governs"| SD end

subgraph Agents["Cloud & Teammate Agents"] A1["Personal Dot"] -->|"Write / Update"| SD A2["Coworker Dots"] -->|"Write / Update"| SD A3["Automations"] -->|"Write / Update"| SD end ```

To prevent concurrent agent contributions from turning the documentation into chaos, Spaces utilizes page instructions modeled after local `.agent-md` files. These instructions define clear layout standards, cite sources accurately, and structure embeds like interactive artifacts or custom HTML visualizations. Automations can be scoped broadly or narrowly—applied to individual dots, pinned to specific pages, or bound to entire cross-functional teams in ChatGPT.

- **Finance:** Autonomous cloud agents generate scheduled weekly analytics reports hooked into connected enterprise cloud data. - **Engineering:** Aggregates open pull requests, project scope, and Directly Responsible Individuals (DRIs) onto a consolidated triage page. - **Research:** Tracks persistent, long-running model evaluations and research experiments. - **Event Planning:** Managed DevDay speaker slides, booth operations, and hardware prep like ModRetro to shield the presenter from late-night Slack disruptions.

[17:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=1020s) Shared Infrastructure: Plugins, WebMCP, and the Plugin Hero

Resolving an outage involves much more than producing a green pull request; engineers must deliver postmortems, stakeholder briefings, and incident blog posts. To turn isolated prompt rules into scalable assets, teams deploy versioned, shareable plugins and extensions across their Codex application cockpit. In fact, both OpenAI's meetings tool and code review product are built directly on top of these very same plugin components.

| Component / Standard | Purpose and Capabilities | |:--- |:--- | | **Plugin Extensions** | Custom UI interfaces embedded within the Codex application to serve as an operational cockpit. | | **Sites + Auth Connectors** | Facilitates secure authentication into custom internal sites using ChatGPT accounts. | | **Model Context Protocol (MCP)** | Cloud-hosted MCP servers deployed with native authentication layers for secure data queries. | | **WebMCP** | Dual-use tool interfaces engineered for synchronous manipulation by both humans and AI models. |

Rather than merely consuming more tokens or spinning up disconnected sub-agents, the primary focus of agentic engineering shifts toward building reusable internal leverage. Early adopters must evolve into the "plugin hero of the company," packaging workflows, automations, and domain skills so that an entire organization can collaborate with their autonomous systems. Beyond core code debugging, these Spaces and dots handle non-engineering work streams just as effectively, ranging from video production shoots to team editorial calendars.

[20:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=1200s) Staying in Sync: Voice, Prototyping, and Ambient Agent Support

When on set shooting launch videos, the environment is typically hectic and scrambled, but having an autonomous agent running in the background fundamentally changes the workflow. Rather than halting progress while filming, the agent proactively works through complex, ambitious tasks designed to unblock itself, queueing up clear summaries for short breaks. If there are only ten minutes to spare, a quick glance at the update is enough to review progress, evaluate feedback, and approve documentation changes or newly spun-up sites that the rest of the team can already inspect. When time is even tighter, the speaker switches to voice mode for rapid-fire communication on the go.

The agent also plays an integral role across cross-functional content planning with creative and marketing teams. During fast-paced brainstorming sessions in Slack or live meetings, fleeting creative sparks often risk falling through the cracks. The agent acts as an accountability layer: the speaker can effectively "shout it into the ether," whether it is an offhand thought for a blog post or a launch video concept. Sometime later, the agent turns that ambient idea into an actionable prototype—delivering a drafted site, a slide deck, or a structured proposal exploring how to frame an advertisement or execute an upcoming launch.

```mermaid flowchart TD accTitle: Creative Brainstorm to Agent Artifact Pipeline accDescr: Diagram illustrating how brainstorming inputs from voice or Slack are turned into prototypes by the background agent.

subgraph Capture ["Input & Ambient Ideation"] A["Slack Brainstorms & Meetings"] B["On-Set Voice Notes & Quick Check-ins"] end

subgraph AgentAction ["Autonomous Execution"] C["Persistent Agent / Codex"] C -->|"Self-unblocking tasks"| D["Draft Prototypes & Docs"] end

subgraph Review ["Team Collaboration"] E["Mockup Sites & Presentations"] F["Team Review & Launch Strategy"] end

A --> C B --> C D --> E E --> F ```

- **On-set catchups:** The agent handles background execution during video shoots and pushes concise updates ready for quick breaks. - **Voice interaction:** Serves as the fastest interface when manual reading or typing is impractical. - **Prototyping momentum:** Rapid skill- and plugin-building allows raw concepts dropped into chat to reemerge organically as functional web mockups and presentation decks.

---

[21:23](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=1283s) Shifting from the Coding Cave to Multiplayer Collaboration

These background automations have created a noticeable mental shift by finally returning the speaker's attention to higher-level creative thinking. Rather than being confined to narrow execution, the speaker can entertain bigger ambitions and spend genuine time engaging with colleagues. While technical disagreements naturally happen, having teammates pick up and advance agent-assisted work makes engineering feel genuinely social again. In an era where it has become tempting to isolate yourself with an autonomous coding agent until 3:00 a.m., the speaker rejects that purely "single player" mindset, noting that the entire reason to join a company is to build things alongside talented people.

This dynamic brings to life the popular sentiment: "I want AI to do my laundry and wash my dishes so I can make art." By letting automated agents take on the repetitive, draining chores of development—the equivalent of doing the dishes and folding laundry—practitioners are freed to tackle the exploratory, creative parts of the craft. Over recent months, this freedom has translated into far richer, more collaborative engagements across research, product, creative, and marketing teams, pulling engineers out of isolated "caves" and back into collaborative teamwork. The session closes with an invitation for builders to adopt these tools not merely for solo productivity, but to elevate collaboration across their entire organizations.

- **Reclaiming attention:** Automating rote operational chores frees up cognitive bandwidth to think bigger and align across teams. - **Avoiding the 3:00 a.m. coding silo:** Solo marathons with a coding agent isolate engineers; multiplayer workflows intentionally bring humans back into the loop. - **Delegating digital chores:** Routine task handling allows engineers to spend their time on genuine creative problem-solving across research, design, and marketing.

## Notable quotes > [00:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=0s) glue for all these systems — Jason

> [02:08](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=128s) half a PM and also customer support — Jason

> [05:04](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=304s) top three like AppShot users of all time — Jason

> [06:17](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=377s) remote control on steroids — Jason

> [06:17](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=377s) feel like a superhero — Jason

> [06:17](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=377s) another wave of AGI — Jason

> [10:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=600s) Maybe we'll get there one day — Jason

> [10:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=600s) I think it might be guardian mode. I think I saw a Slack message from a guy whose first name starts with T. Can you also check the configuration for the feature flags, caching updates, and also compare some pull requests? — Jason

> [10:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=600s) Oh, that's a good idea. Let's turn it into a blog post. Please go draft something that we can review later. — Jason

> [10:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=600s) And all of a sudden, I feel like the CEO who's just tagging people left and right. — Jason

> [17:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=1020s) plugin hero of the company — Jason

> [20:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=1200s) shout it into the ether — Jason

> [21:23](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=1283s) I want AI to do my laundry and wash my dishes so I can make art. — Jason

## Mentioned OpenAI, Developer Experience team, Jason, Codex, Dot, Space, Slack, Twitter, AppShots, ChatGPT, Microsoft Teams, ModRetro, DevDay, Model Context Protocol (MCP), WebMCP

## Video description Follow a 2am outage from the first Slack message to a reviewed fix. See how voice, Appshots, plugins, and meeting notes help a persistent personal agent investigate and keep the team informed.

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

中文简报

OpenAI将Codex转向云端智能体以消除开发者瓶颈 单人AI工具会让个体工程师沦为运营瓶颈，因而需要持久化云端智能体与共享工作区来协调整个团队的任务。 OpenAI开发者体验团队的Jason梳理了从高摩擦的个人瓶颈转变为部署像Dot这样持久化“多人”AI智能体的演进历程。早期的单人工作流依赖人工提示词和个别AppShots，而现代系统则结合了云沙盒、智能体语音以及混合本地执行，能够自主进行长时间的排查调查。共享上下文通过协作空间（Spaces）、页面指令和标准化插件来维护，而非局限于孤立的聊天会话。最终，对机械性数字维护工作的自动化可防止开发者陷入深夜单打独斗的编码孤岛，并重新将精力聚焦于富有创意的全团队协同问题解决。 OpenAI强调了从“超强个人贡献者（IC）”向多人系统的运作模式转变，并警告称使用本地AI工具的高产单兵工程师很快会沦为组织瓶颈。 (0:00) AppShots约占演讲者Codex会话的30%，其捕获的是应用程序元数据、活跃URL和首屏以下的内容，而非简单的静态截图。 (5:04) 云原生持久化智能体在拥有专属浏览器和文件的独立沙盒中运行，同时保持绑定的本地访问权限，以便在获得批准后在工程师的机器上执行特权任务。 (6:17) OpenAI的内部工作流利用受页面指令（.agent-md）和WebMCP接口管辖的协作空间（Spaces），允许多名人类和智能体协作者写入同一个单一事实来源。 (13:00)

Reading summary

Jason from OpenAI's Developer Experience team argues that maximizing individual developer productivity creates an operational bottleneck, requiring a shift toward persistent, shared AI workflows that collaborate across entire teams. The Ceiling of the Solo Contributor Bottleneck (0:00) Early developer tooling focused heavily on individual leverage through computer access, screen reading, and local command execution. While tools like AppShots—which capture an application's DOM metadata, active URLs, and below-the-fold content—accounted for roughly 30% of Jason's Codex sessions, relying strictly on personal triggers created an operational ceiling. High individual actions per minute (APM) turned the engineer into a coordinator micromanaging disconnected runs until 2:00 or 3:00 AM. Without cross-functional visibility, manual automations like scheduled heartbeats and pinned threads failed to transfer state. Adjacent teams often ran duplicate investigations for the same outages, turning individual contributors into impromptu project managers and support liaisons rather than eliminating repetitive coordination. Cloud Agents and Multimodal Ambient Inputs (6:17) To escape local machine limits, persistent cloud agents like Dot operate in isolated cloud sandboxes with independent browsers, files, and runtimes. These environments persist even when an engineer's laptop is closed or asleep. When elevated access is required, such as internal authentication or local apps, the cloud agent can alert a mobile device to request remote execution on the physical machine. Simultaneously, input modalities shifted from one-way text dictation to agentic, two-way voice. Team conversations and spontaneous brainstorming during live outage calls are automatically transcribed in the background, allowing agents to ingest messy, unstructured hunches. Instead of engineers having to write pristine prompts, the agent converts spoken dialog into actionable background tasks such as querying Slack, scraping customer feedback IDs, or drafting postmortems. Shared Spaces and Standardized Team Capabilities (13:00) Isolated local context vaults have been replaced with collaborative cloud Spaces where both humans and agents read and write against a shared document model. To prevent multiple agents from corrupting shared documentation, Spaces employs page instructions modeled after `.agent-md` files, establishing layout standards and embedding guidelines across teams in finance, engineering, and research. To institutionalize these workflows across organizations, internal capabilities are packaged into versioned plugins, sites with native ChatGPT authentication, and Model Context Protocol (MCP) servers. WebMCP interfaces allow dual-use control where humans and models manipulate identical tools. Jason notes that OpenAI's own code review and internal meetings tooling were built directly on top of these shared plugin components, urging early adopters to become internal 'plugin heroes' who build leverage for the whole team. Reclaiming Attention Through Multiplayer Engineering (21:23) Persistent background agents enable asynchronous progress across cross-functional tasks. During video shoots or marketing planning, agents work through self-unblocking milestones, delivering concise status reports for quick breaks or converting casual chat brainstorming into drafted slide decks and prototype web sites. Jason frames this operational shift as a necessary rejection of the isolated coding cave. Offloading administrative chores—such as triage, cross-checking feature flags, and tracking action items—restores cognitive bandwidth for creative technical debate and collaborative alignment across disciplines. The presentation leaves open how fully automated agents will interact directly in live meetings without prompting, as direct real-time agent voice participation in team calls remains an unfulfilled future milestone.

Detailed notes — zh

## Background 该视频由 OpenAI 于 2026 年 10 月 9 日发布在 YouTube 平台，为 DevDay 2026 的演讲实录。视频简介指出，内容围绕一场凌晨 2 点的突发故障排查展开，展示了如何借助语音、Appshots、插件和会议记录，让常驻个人 Agent 协助排查并实时向团队同步进展，实现从首条 Slack 报警到最终代码修复审查的全流程协同。 ## TL;DR OpenAI 开发者体验团队的 Jason 分享了开发者如何打破单打独斗的“超级个体”瓶颈，迈向基于 Codex 的多人协作（Multiplayer）模式。演讲系统梳理了常驻云端 Agent（Dot）的核心工作流，涵盖利用 Appshot 完整抓取应用上下文、双向语音交互，以及打通端云协同的本地电脑反向控制机制。同时，团队引入了基于云端空间（Space）与 `agent.md` 规则的协作架构，推动个人自动化向可共享、版本化的团队插件基础设施演进。整场分享强调让 AI 承担繁重重复的杂务，使开发者从全流程“系统胶水”中解脱出来，重拾与跨职能团队并肩创造的乐趣。 ## Atmosphere & style 现场氛围真诚坦率且极富开发者共鸣，讲者以自身从普通观众到台前分享者的转变开场，毫无保留地吐露高 APM 微观管理与凌晨熬夜排查的切身痛点。叙事节奏紧凑而富有前瞻性，既有应对系统突发故障与工具链整合的硬核实战剖析，又贯穿着走出封闭敲代码“洞穴”的感性反思。整场演讲在展现前沿 Agent 协同架构的同时，洋溢着对技术协作本质的人文关怀，带给听众一种从单机孤勇走向团队温暖的释怀感与启发。 ## Bulletin - [00:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=0s) 打破“超级个体”的胶水瓶颈：单点赋权的 AI 工具虽然提升了个人生产力，却让工程师沦为手动串联各系统并陷入微观管理的“胶水人”；向多人协作（Multiplayer）演进的核心是构建能自动捕获沟通上下文并跨工具自主推进的系统，从而解放单点瓶颈。 - [05:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=300s) Appshot 与云端常驻 Agent（Dot）协同：通过双 Command 键触发的 Appshot 不仅截屏，还能抓取应用元数据、底层 URL 及首屏折叠下的完整上下文（占讲者 Codex 会话起点的 30%）；结合云端 24 小时常驻且具备双向语音交互（速度达打字 3-4 倍）的个人 Agent“Dot”，实现了端云联动的全天候自动排查。 - [12:35](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=755s) 以 Space 与 `agent.md` 构建团队单一事实源：告别不可继承的本地脚本与记忆库，团队通过云端共享空间（Space）汇聚排查时间线与数据看板，并利用页面级指令 `agent.md` 规范多 Agent 协同写入的格式、引用与内嵌 HTML 组件更新，避免多方操作冲突。 - [17:40](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=1060s) 沉淀企业级代理基础设施（Agentic Infrastructure）：下一阶段的技术跃迁并非单纯消耗更多 Token，而是将规则自动化、可版本化控制的插件与扩展（Plugins & Extensions）以及 WebMCP 协议沉淀为团队共享资产，让开发者从深夜独自写代码的“洞穴”回归高价值的跨团队创意与协作。 ## Key takeaways - [00:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=0s) 开发者使用 AI 经历了从“单点个人辅助”到“本地权限扩展的超级个体（IC）”，再到“团队多人协作（Multiplayer）”的三个演进阶段。 - [00:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=0s) 在“超级个体”阶段，受限于个人每分钟操作数（APM），工程师极易沦为连接各系统的全链路“胶水”，陷入无休止的微观管理与深夜加班。 - [02:30](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=150s) 早期半自动化与本地脚本的最大痛点在于“不可继承”，同事无法接手进度，导致多组工程师在故障排查中闭门造车、重复造轮子。 - [02:30](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=150s) 构建 Multiplayer 体系依赖三部曲：注入完整上下文、在超出人脑容量时保持任务井井有条运转、以及将个人工作流沉淀为全队共享的技能与插件。 - [05:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=300s) Appshot 功能通过双 Command 键触发，可一次性捕获当前屏幕及应用内部的元数据、URL 和首屏下方折叠内容，贡献了讲者 30% 的 Codex 会话起点。 - [05:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=300s) 个人常驻 Agent（Dot）运行在拥有独立虚拟电脑、浏览器和文件系统的云端，支持 24 小时不间断后台运转，并可在授权后反向调用本地电脑执行“最后一公里”测试。 - [05:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=300s) 双向智能语音（Agentic Voice）将沟通速度提升至打字的 3 到 4 倍，使 Agent 能够实时语音汇报、主动反问并协助头脑风暴。 - [10:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=600s) 会议工具与语音交互允许极度混乱随意的表达，后台常驻的 Dot 会自动从多人讨论转录中清洗提取关键线索，并调用 Slack 或 Browser 工具推进后续动作。 - [12:35](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=755s) 具身化（Embodiment）让 Agent 拥有独立身份属性，团队成员可在 Slack 或 Microsoft Teams 中直接 `@Dot` 指派任务，将日常闲聊与讨论直接转化为云端上下文。 - [12:35](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=755s) 云端协作空间（Space）取代了单机时代的本地记忆库（Local Memory Vault），成为全员与所有个人及团队级 Agent 共同维护的单一事实源（Single Source of Truth）。 - [14:45](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=885s) 文档层级的 `agent.md`（页面指令）强制规范了多 Agent 协同写入时的人类可读性、引用来源及内嵌 HTML 视图与自定义 Artifacts 的更新逻辑，防止协同冲突。 - [14:45](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=885s) 页面与团队级自动化已广泛覆盖财务周报生成、研发 PR 覆盖范围与直接责任人（DRI）看板汇总、长周期科研追踪以及大型活动筹备。 - [17:40](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=1060s) 完整的代理基础设施（Agentic Infrastructure）由保持状态更新的“规则与自动化”、可版本控制与分发的“插件与扩展”、统一操作台 Codex 以及支持双向协同的 WebMCP 协议共同构成。 - [20:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=1200s) 随行个人 Agent 能在片场或会议等碎片化场景中担任“问责伙伴”，不仅能通过 10 分钟简报或语音通话同步进度，还能捕捉一闪而过的灵感并自动生成原型站点与策划方案。 - [20:47](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=1247s) 自动化的终极意义在于替人类承担“洗碗洗衣服”般的琐碎运维与样板工作，把注意力重新还给人，让开发者走出独自熬夜写代码的“洞穴”，回归跨团队的深度创造与协作。 ## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=0s) 从“超级个体”到“多人协作”：打破工程师的微观管理瓶颈 演讲者是来自 OpenAI 开发者体验（Developer Experience）团队的 Jason。回顾过去一年的经历，Jason 感慨万千：去年 DevDay 他还只是坐在台下的普通观众，仅仅七个月前加入 OpenAI，而如今已经站在台上进行分享。在这七个月里，团队高频交付了海量功能。然而，随着个人生产力的暴增，Jason 逐渐发现了一个致命痛点——自己不知不觉成了所有系统之间的“胶水”，也成了整个工作流推进的最大瓶颈。现场许多观众纷纷举手表示感同身受：手头要处理的事情太多，每天陷入无休止的微观管理（micromanaging）。 针对这种演变，Jason 梳理了开发者使用 AI 工具的三个阶段： 1. **初期探索**：“我能用 AI 做什么？”——仅限于单点的个人辅助； 2. **能力扩展**：“AI 拥有了我的电脑、文件、浏览器和应用的访问权限后能做什么？”——变成了单打独斗的“超级个体贡献者”（super-powered IC）； 3. **团队协作（Multiplayer）**：“如何构建一套系统，让团队所有成员一同受益，而不是自己一个人扛下全部？” 所谓的“多人协作”（Multiplayer），绝非简简单单地建一个包含若干同事的公共聊天窗口或多人群聊。它的本质在于：开发者不必再从头到尾独自推进每一项任务。系统能够自动捕获日常与同事的沟通内容，让不同工具与 AI 自行协同运转；AI 会主动记录哪些事情已经完成，并在关键决策点上主动向人类团队寻求判断，让个人从“全链路胶水”中解脱出来。 ```mermaid flowchart LR accTitle: 开发者工作模式的演化 accDescr: 展示从单人指令到超级个体，再到多人协同系统的三个演进阶段。 subgraph S1["第一阶段：单点个人"] A["问答式交互<br/>AI 作为简单工具"] end subgraph S2["第二阶段：超级个体 (瓶颈)"] B["Computer Use<br/>本地脚本与自动化"] --> C["工程师成为全流程胶水<br/>陷入微观管理与高 APM"] end subgraph S3["第三阶段：多人协作 (Multiplayer)"] D["持续在线的 Agent (Dot)"] --> E["上下文自动捕获与共享"] E --> F["团队技能与插件复用<br/>摆脱单点瓶颈"] end S1 --> S2 --> S3 ``` --- ### [02:30](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=150s) 故障响应的演进历程与 Multiplayer 雏形 Jason 提出了一个极具代表性的假设场景：早上 8 点打开社交平台 X（Twitter），突然看到用户在抱怨使用额度限制（usage limits）或限流（rate limit）报错。此时前线一片混乱——不知道究竟哪里崩了，不知道内部是否有人正在排查，但此类故障必须严肃对待。这需要有人全程跟进、在合适时机向上升级（escalate），并确保线索不会遗失在浏览器标签页或杂乱的 Slack 频道里。 面对这种突发状况，过去大半年的工作流经历了三个截然不同的演化阶段： * **六个月前（全手动 + 本地 Codex）**：虽然开始借助 Codex 或内部工具去查 Slack，但所有逻辑均跑在自己的本地电脑上。工程师需要手动把各个系统的碎屑信息拼凑起来，不仅繁重，而且极其消耗精力。 * **三个月前（半自动化任务与心跳检测）**：任务开始能够代表个人去执行，例如在 Slack 钉住线程（pin a thread）、设置心跳自动化（heartbeat automation），期望一切信息按时抓取。然而最大的硬伤在于**不可继承**——同事无法直接接手进度，工程师既成了半个项目经理（PM），又成了半个客服；更滑稽的是，其他几个组的工程师往往在同时做一模一样的排查，大家都在闭门造车、重复造轮子。 * **当下（基于 Dot 与 Spaces 的 Multiplayer 模式）**：当有人在 Slack 上提出问题或发表评论时，个人的常驻 Agent（Dot）能够自动接入、跟踪推进，完全不受平台限制（不管是邮件、Slack 还是浏览器）。Dot 会在工程师与团队、其他工程师或客户沟通时，自主理解上下文、解除自身阻塞（unblock itself）。 团队不再需要折腾 15 个带心跳检测的置顶自动化、一个本地记忆库（memory vault）以及永远更新不全的 Markdown 文档；随着工具被更广泛地理解，这些工作流可以固化为可共享的 Agent 技能、插件（plugins）和扩展（extensions），直接为全员赋能。Jason 概括构建这一体系的“三部曲”： 1. **输入上下文**：如何将桌面、浏览器、自己与同事脑海中、以及 Slack 和邮件中的上下文完整注入 Agent； 2. **保持工作运转与组织化**：如何让海量细节在超出人脑容量时依然井井有条； 3. **团队共享与升级**：如何让成果普惠全队，提升整体战斗力。 --- ### [05:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=300s) Appshot、端云协同具身化与双向语音交互 在“获取上下文”环节，Jason 详细展示了 **Appshot** 这一杀手级功能。在键盘上按下空格键两侧的双 Command 键，系统不仅会截取当前屏幕，还会抓取整个应用内部的完整上下文——包括元数据、底层 URL 以及折叠在首屏下方（below the fold）的所有内容。过去打开 Codex 往往面对一个空白的输入框，还得手动输入“请帮我读 Slack”；而 Appshot 能让 Agent 直接“就地与你相遇”（meet you where you are）。据 Jason 统计，他在 Codex 中开启的会话有 30% 均来自 Appshot。 然而，单纯的 Appshot 并没有彻底解放他：由于频繁使用，Jason 戏称自己成了“全球前三大 Appshot 重度用户”，每天依然要加班到凌晨两三点。因为他受限于个人的“APM”（Actions Per Minute，每分钟操作数），依然在手动串联各种任务。转折点在于 **Dot** 的持续在线（persistent）、主动出击（proactive）以及具身化（embodied）特性： * **云端常驻执行**：Dot 运行在云端，拥有专属的虚拟电脑、浏览器和文件系统。即便本地电脑关机，后台调查依然 24 小时不停运转； * **本地电脑的反向控制（Remote Control on Steroids）**：在赋予相应权限后，云端的 Dot 能将你的本地电脑作为“最后一公里”的执行节点。当云端调查需要登录特定账号、调用本地专有软件或进行本地测试时，Dot 会主动发问：“你本地浏览器登录了吗？能否授权我访问你的电脑来跑一下测试？”； * **双向智能语音（Agentic Voice）**：传统的语音转文字（Dictation）只是单向输入；而双向语音交互让用户以 3 到 4 倍于打字的速度与 Agent 沟通。Agent 在后台阅读分析后实时语音汇报，并主动反问、协助头脑风暴，带来了如同全新 AGI 浪潮般的协作体验。 ### [10:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=600s) 会议语音与个人 Agent 的后台自动化协作 在传统的单人使用场景中，人与 AI 的对话更像是一种“自言自语”；而随着会议工具的引入，对话变成了多向互动的网络。工程师不仅在与同事沟通，而且每一次发言都在隐形地为后台的个人 Agent（Dot）提供 Prompt。虽然目前让自己的 Dot 直接加入通话并插话发言可能还为时过早，但在团队对话中通过语音提示 AI 已经极其高效。 ```mermaid flowchart TD accTitle: 会议语音到后台任务流转流程 accDescr: 展示从会议混乱语音中由Dot捕获上下文并触发后台协作的完整流程 subgraph AudioInput ["输入层 (语音与沟通)"] Voice["会议凌乱语音 / 多人讨论"] Prompt["中途即兴指令 (如撰写草稿/时间线)"] end subgraph AgentCapture ["捕获与理解层 (Dot)"] Dot["后台常驻个人 Agent (Dot)"] Clean["自动整理杂乱信息 / 提取关键线索"] end subgraph ActionExecution ["执行层 (外部工具连接)"] SlackConn["Slack Connector (私信确认/主频道同步)"] BrowserConn["Browser Agent (收集线上反馈 ID)"] DocGen["自动生成博客草稿 / 剧本时间线"] end Voice --> Dot Prompt --> Dot Dot --> Clean Clean --> SlackConn Clean --> BrowserConn Clean --> DocGen ``` 语音输入的核心优势在于“容许极度的混乱与随意”，并将清洗整理的重活完全交给模型。讲者举了一个真实的会议场景：工程师在通话中极其随意地念叨：“我觉得可能是守护模式（guardian mode）的问题；我好像看到一个名字以 T 开头的人发的 Slack 消息；你能再顺便查一下 Feature flags 的配置、缓存更新，再对比几个 Pull Request 吗？”这种又长又散的内容如果靠手动打字，工程师往往只会截一个 Appshot 然后敷衍地发一句“请排查”，随后抱怨模型给不出好结果。但如今，会议转录由具备持久性与主动性的 Dot 在后台全自动捕获，并默默推进工作，彻底免去了人工记录会议摘要的负担。 除了解除记录负担，会议中迸发的灵感也能被即时转化为行动。当团队讨论出一个优秀的博客构思、广告文案或产品文案时，讲者会直接在通话中指派 Agent：“这个点子不错，把它做成一篇博客草稿，晚点我们来评审；用那个新的剧本工具排一下时间线。”在会议结尾处，除了给同事分配 Action Items，还可以直接向 Agent 下发复杂指令： - 调用 Slack Connector 去向某两个人发私信，确认他们是否理解背景，收到回复后再同步回 Slack 主频道。 - 调用 Browser 工具在网页端联系特定用户，索取反馈 ID（Feedback IDs）。 - 摆脱过去“反复截图（Appshot）并在每次会后逐一手动作答”的琐碎循环，完全依赖常驻 Agent 基于上下文的主动执行。 --- ### [12:35](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=755s) Agent 的具身化呈现与云端协作空间（Space） Agent 的交互正在跳脱出单一的会议场景。日常与同事的闲聊与讨论，最终都会转化为云端 Agent 的上下文与 Prompt。为了让这种协作更具交互感，OpenAI 为 Agent 赋予了具身化（Embodiment）的身份属性。在 Slack 或 Microsoft Teams 等企业通讯工具中，用户可以直接像 @ 真实同事一样 @ 自己的专属 Dot（例如 `@Jason dot`），让它跟进排查。这种体验让讲者调侃道：“突然之间，我就像个 CEO 一样到处在通讯软件里疯狂 @ 人指派活了。”未来除了个人专属的 Dot，还将推出团队级 Dot，并在更多工作界面中无缝集成。 过去很多工程师依赖本地脚本和自动化流，这种单机模式存在两大致命痛点：第一，其他团队成员完全无法参与；第二，无法享受云端高算力 Agent 的协同红利。正如版本控制与单一事实源（Single Source of Truth）让软件工程效率实现飞跃一样，知识工作也需要类似的底座。为此，团队引入了“空间（Space）”概念。空间就像是云端的多人共享“记忆保险库（Local Memory Vault）”： ```mermaid flowchart LR accTitle: Space 团队协作与单一事实源架构 accDescr: 展示以 Space 为核心的知识库如何由不同 Dot 和自动化流程共同维护 subgraph TeamInput ["输入与代理层"] MemberA["工程师 / Dot A"] MemberB["分析师 / Dot B"] TeamDot["团队 Agent"] end subgraph CloudSpace ["单一事实源 (Space)"] SpaceRoot["云端 Space 知识库"] AgentMD["agent.md / Page Instructions"] Artifacts["嵌入式 HTML / 可视化分析"] end subgraph Outcomes ["自动化产出"] Timeline["实时排查时间线"] WeeklyReport["周度分析报告 / PR 状态面板"] end MemberA --> SpaceRoot MemberB --> SpaceRoot TeamDot --> SpaceRoot SpaceRoot --- AgentMD AgentMD --> Artifacts SpaceRoot --> Timeline SpaceRoot --> WeeklyReport ``` 在排查故障时，工程师可以让 Agent 基于既定模版直接新建一个页面，并将其共享给全组及同事的 Dot。只要指定 Dot 持续跟踪动态并更新内容，云端文档便能时刻保持最新，成为全员与所有 AI 共享的核心事实源。 --- ### [14:45](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=885s) `agent.md`、页面指令与多场景团队自动化 为了确保各类 Agent 在协同读写时不会把文档格式搅得一团糟，系统引入了类似目录中 `agent.md` 的规范机制，并将其作为页面指令（Page Instructions）内置在文档层级： - **规范输出格式**：强制保证各 Agent 写入的内容具备良好的人类可读性、正确的引用来源以及统一的格式排版。 - **支持富文本与组件**：当文档中包含自定义 Artifacts、内嵌 HTML 视图或数据图表时，`agent.md` 能够明确规定自动化流程应如何去更新这些组件，防止不同同事的 Dot 在协同操作时出现冲突。 这种自动化能力不仅局限于个人 Dot，还可被定义在具体页面或整个团队维度： - **财务团队**：云端 Agent 每周自动抓取后台各项数据，直接在特定文档内输出周度分析报告。 - **研发工程**：自动汇聚、整理各个 Pull Request 的覆盖范围，明确直接责任人（DRI），并在单页看板中直观呈现所有待合并项。 - **科研与实验**：长效追踪周期漫长的科研实验进程。 - **大型活动筹备**：讲者在筹备 DevDay 期间，依靠这套体系托管了绝大多数繁重事务——涵盖演讲幻灯片修改迭代、场外展位搭建跟进乃至 Retro 硬件复盘等，从而避免整天深陷在 Slack 的深夜消息轰炸中。 通过自动化将各种证据链（调查时间线、线上 Feedback IDs、聊天上下文链接与引用）汇聚至同一 Space 后，团队便能形成假设，并直接派出云端 Agent 去复现 Bug、展开排查并寻找修复方案，而无需任何人类员工在各系统之间充当传话的“胶水人（Glue）”。 --- ### [17:40](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=1060s) 从指令到插件生态：打造团队共享的 Agent 基础设施 在软件研发与运维实战中，提 Pull Request 往往只是冰山一角，后续还有复盘报告（Postmortem）、演示文稿以及技术博客需要撰写。这些流程往往依赖不同维度的专业技能（Comms 或 Design），而这些技能本质上就是基于指令的插件（Instruction-based Plugins）： | 体系层级 | 核心属性与定位 | 典型应用与价值 | |:--- |:--- |:--- | | **规则与自动化 (Rules & Automations)** | 保持任务持续运转、保证数据与状态实时更新 | 抓取 Feedback ID、自动维护故障调查时间线 | | **插件与扩展 (Plugins & Extensions)** | 具备可共享性、可版本化控制（Versioned）、支持全员分发 | 构建企业内部共享工具链、定制通用研发/沟通技能 | | ** Codex 宿主环境 (Cockpit)** | 作为集成一切的统一操作台 | 会议产品、代码审查（Code Review）产品皆基于同套组件构建 | | **Web 与 MCP 协议 (Model Context Protocol)** | 支持 ChatGPT 快捷登录与 Connector 桥接；提供带鉴权的 MCP 服务端 | 借助 WebMCP 构建人类与 AI 均可无缝协同使用的双向工具 | 讲者指出，当前的开发者大多数是早期的尝鲜者（Early Adopter），大家普遍在思考“我个人能用这些模型工具做些什么”。但下一阶段的技术跃迁绝非仅仅堆砌更多 Agent 或消耗更多 Token，真正的关键在于构建能够跨团队沉淀的“代理基础设施（Agentic Infrastructure）”，把自动化工作流、插件与技能沉淀为团队的通用资产。 在公司内部搭建这套基础设施、成为全公司的“插件英雄（Plugin Hero）”，正是当下每一位参会开发者最具价值的机遇。这种协作模式不仅局限于工程故障处置，讲者日常也深度利用 Dot 和 Space 来进行视频拍摄排期、全组内容运营规划等更为多元的复合任务。 ### [20:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=1200s) 随行个人 Agent：从碎片时间汇报到创意灵感落地 演讲者分享了自己在高强度现场工作中使用个人 Agent（他的 "dot"）的真实体验。例如在拍摄产品发布视频时，现场往往极其混乱且节奏飞快，但他完全不需要被动等待或被杂务打乱阵脚，因为他的 Agent 会在拍摄间隙主动同步最新动态。他尝试给 Agent 分配一些极具挑战性的任务，让它自己寻找路径排查阻碍并推动进度。如果抽得出 10 分钟空闲，他就会快速扫一眼 Agent 汇总的最新状态进展，团队其他成员也能同步看到这些透明的信息流；随后只需基于反馈和审批流程，就能迅速敲定站点修改或文档变更。如果时间更紧张，连看屏幕的功夫都没有，他会直接“给它拨通语音通话”，利用语音交互实现最高效的即时沟通。 ```mermaid flowchart TD accTitle: 个人 Agent 在多任务场景下的协作流 accDescr: 展示了从现场拍摄与团队头脑风暴，到 Agent 自主推进与产出交付的完整流转过程。 subgraph Input["输入场景"] A["片场拍摄间隙<br/>碎片化时间"] B["创意/市场团队<br/>Slack 脑暴与会议灵感"] end subgraph Agent["Dot (个人 Agent) 核心处理"] C["自主解锁卡点<br/>推进任务进度"] D["抓取灵感并防遗漏<br/>调用 Skills & Plugins 原型构建"] end subgraph Output["交付与交互"] E["10 分钟文字简报 /<br/>即时语音通话"] F["自动化输出演示文稿、<br/>原型站点与策划方案"] end A --> C --> E B --> D --> F ``` 这种机制在内容策划阶段同样发挥了巨大威力。当演讲者与创意团队、市场团队在 Slack 或会议中进行头脑风暴时，Agent 扮演了忠实的“问责伙伴”，绝不让任何闪光的金点子溜走遗失。为了更好地发挥其威力，他构建了大量的技能（Skills）、插件（Plugins）以及原型站点。现在，无论冒出什么关于博客文章还是发布视频的奇思妙想，他只要“朝着虚空喊上一嗓子”（Shout it into the ether），不久之后，Agent 就会主动发来一个包含完整原型站点、演示文稿或营销构想的方案，清晰勾勒出广告该怎么拍、发布流程该如何推进。 - **多模态即时跟进**：在 10 分钟以内的休息间隙阅读透明更新，极端赶时间时则直接一键呼叫，利用自然语音快速同步。 - **创意落地零遗失**：开会或在 Slack 讨论时随手抛出想法，Agent 会在后台自动完成调研、原型搭建与演示制作，防止灵感被日常琐事淹没。 - **注意力重新归位**：近几个月来，这一整套自动化体系最大的意义在于“把注意力重新还给了人”，让开发者能够腾出心力与同事展开深层互动、放飞更大胆的构想。 --- ### [20:47](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=1247s) 走出“洞穴”：从单人独斗走向真正的多人协作 演讲者动情地谈到了人与人协作的本质价值。尽管团队协作有时伴随着争论与分歧，但与优秀的伙伴并肩作战、由团队成员接力完成自己未竟的工作并持续推进，才让人真正找回置身于团队之中的充实感。进入 2026 年，开发者很容易陷入一种极端模式——一个人带着自己的 Coding Agent 闭门造车，直接死磕到凌晨 3 点。但演讲者直言，这种单打独斗的生活对他而言“一点也不好玩”。加入一家公司的初衷，本就是为了能与出类拔萃的伙伴聚在一起，共同探索并解决难题。 这也让他深刻共鸣了网络上流传的一句话：“我希望 AI 替我洗衣服、洗碗，这样我就可以去创作艺术了。”在实际工作中，写样板代码、排查琐碎运维流程就像是“洗碗和洗衣服”，而深度的思考、沟通与创造才是真正的“艺术”。得益于自动化工具承担了脏活累活，他在过去的几个月里得以从独自敲代码的“洞穴”（in the cave）中走出来，把更多宝贵时间投入到与研究、创意、产品和市场团队的紧密碰撞中，体验到了前所未有的工作乐趣。最后，他由衷呼吁所有开发者亲自尝试这些工具，跳出单人模式，将更多协作的温度重新带回日常工作之中。 ## Notable quotes > [00:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=0s) 我能用 AI 做什么？ — Jason > [00:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=0s) AI 拥有了我的电脑、文件、浏览器和应用的访问权限后能做什么？ — Jason > [00:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=0s) 如何构建一套系统，让团队所有成员一同受益，而不是自己一个人扛下全部？ — Jason > [05:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=300s) 就地与你相遇 — Jason > [05:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=300s) 你本地浏览器登录了吗？能否授权我访问你的电脑来跑一下测试？ — Dot > [10:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=600s) 我觉得可能是守护模式（guardian mode）的问题；我好像看到一个名字以 T 开头的人发的 Slack 消息；你能再顺便查一下 Feature flags 的配置、缓存更新，再对比几个 Pull Request 吗？ — Jason > [10:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=600s) 这个点子不错，把它做成一篇博客草稿，晚点我们来评审；用那个新的剧本工具排一下时间线。 — Jason > [12:35](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=755s) 突然之间，我就像个 CEO 一样到处在通讯软件里疯狂 @ 人指派活了。 — Jason > [20:00](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=1200s) 朝着虚空喊上一嗓子 — Jason > [20:47](https://www.youtube.com/watch?v=aDTPTwnrRyA&t=1247s) 我希望 AI 替我洗衣服、洗碗，这样我就可以去创作艺术了。 — Jason ## Mentioned OpenAI, Jason, Codex, Dot, Appshot, Space, Slack, X (Twitter), Microsoft Teams, agent.md, Model Context Protocol (MCP), ChatGPT, DevDay 2026 ## Video description Follow a 2am outage from the first Slack message to a reviewed fix. See how voice, Appshots, plugins, and meeting notes help a persistent personal agent investigate and keep the team informed. [Source](https://www.youtube.com/watch?v=aDTPTwnrRyA)

Source quotes

[0:00] Jason: 我能用 AI 做什么？ [0:00] Jason: AI 拥有了我的电脑、文件、浏览器和应用的访问权限后能做什么？ [0:00] Jason: 如何构建一套系统，让团队所有成员一同受益，而不是自己一个人扛下全部？ [5:00] Jason: 就地与你相遇 [5:00] Dot: 你本地浏览器登录了吗？能否授权我访问你的电脑来跑一下测试？ [10:00] Jason: 我觉得可能是守护模式（guardian mode）的问题；我好像看到一个名字以 T 开头的人发的 Slack 消息；你能再顺便查一下 Feature flags 的配置、缓存更新，再对比几个 Pull Request 吗？ [10:00] Jason: 这个点子不错，把它做成一篇博客草稿，晚点我们来评审；用那个新的剧本工具排一下时间线。 [12:35] Jason: 突然之间，我就像个 CEO 一样到处在通讯软件里疯狂 @ 人指派活了。 [20:00] Jason: 朝着虚空喊上一嗓子 [20:47] Jason: 我希望 AI 替我洗衣服、洗碗，这样我就可以去创作艺术了。

Source quotes

[0:00] Jason: glue for all these systems [2:08] Jason: half a PM and also customer support [5:04] Jason: top three like AppShot users of all time [6:17] Jason: remote control on steroids [6:17] Jason: feel like a superhero [6:17] Jason: another wave of AGI [10:00] Jason: Maybe we'll get there one day [10:00] Jason: I think it might be guardian mode. I think I saw a Slack message from a guy whose first name starts with T. Can you also check the configuration for the feature flags, caching updates, and also compare some pull requests? [10:00] Jason: Oh, that's a good idea. Let's turn it into a blog post. Please go draft something that we can review later. [10:00] Jason: And all of a sudden, I feel like the CEO who's just tagging people left and right. [17:00] Jason: plugin hero of the company [20:00] Jason: shout it into the ether [21:23] Jason: I want AI to do my laundry and wash my dishes so I can make art.

Original transcript

[0:00] *music* Whoa. This is cool. I feel like I recognize like half the people in the audience. Um... Thank you all for being here. Last year, I was in the seating over there. And it's kind of crazy to be up here now. But yeah, today I'm really excited to talk a little bit more about multiplayer and what that means. So I'm Jason from the Developer Experience Team at OpenAI. And I've only been here about seven months. But we've shipped a ton of features. And as I got more productive, I felt like at some point I was just like the glue for all these systems, and I felt like I was a bottleneck. for a lot of the things that I was doing. Just as a show of hands, who else feels this way now? There's just so much to do, you're just micromanaging. Yeah. Oh, thank God. But what ends up happening is first as you start, it's just about what I can do with AI. And then it becomes like, what can AI do with access to my computer and its files and the browser and these apps? But I think more than ever with these new tools, a lot of it now has become How can I make systems that bring the rest of my team along, rather than just being this super-powered IC? Thank you. And so when we saw tools like computer use and voice and all these cloud features, I wanted to try them all, but they were still mostly focused on scaling the individual. Right. But now with things like dots, space, that has page instructions, team automations, and plugin extensions A lot of it now has become how we set up the team for success rather than just scaling up the individual. So the talk is called multiplayer. So let me also define what I think is multiplayer, right? It doesn't just mean that I have you know, one chat bar with a bunch of my coworkers talking in the same thread. For me, it's about having the ability to know that I'm not the only individual that has to carry the work all the way through to the end. It means that the conversations I'm having with my teammates are just automatically picked up. And so we can build systems where everything works together and comes together. And, There's other tools and other AI that's helping me keep track of what's been done. and know that it will lean on us to make the right decisions. So let's start with a hypothetical example. Imagine it's me, it's 8:00 AM, I'm on Twitter, and there's some comments about usage limits or rate limit issues. Obviously, I don't know what happened. Right. I don't know what broke. I don't know if anyone else is investigating. But I do know that we take these things really seriously. And if they're related, I need to keep talking of everything. I need to escalate when it makes sense to. I need to make sure that none of all this content gets lost in my browser on a conversation in Slack. Six months ago, I was doing a lot of this manually, right? Manually with codecs at least. I would use internal tools or codecs. I would ask it to check Slack and try to make sense of what's going on. And on top of that, all of it still ran on my computer, and I was still the one pushing things forward, gluing these pieces together. And it was a lot of work. Three months ago, things got a lot better. Tasks could work on my behalf. I would pin a thread, set an automation, and then hope that everything was caught up on time. But the issue was that people couldn't pick up where I left off. And so everything still came through me. I just became like... have a PM and also customer support. And then what you find out is like half the other teams are also doing the same task and just repeating all this work. instead of actually participating in a more unified push. Now I think we're entering a place where multi-player makes a lot more sense, right? We have a world where if someone leaves an issue or comments on Slack, my doc can pick it up and follow along, keep track of things. independent of whether it's email or Slack or a browser or anything else. And then I can just tell my daughter to keep an eye on the investigation and make sense of it and unblock itself. as I interact with other people on my team, the engineers, and even some of the customers. Right? Tools like Dot and Space make it much easier for people to work together without having to do all the stuff that I did, which is like 15 pin automations with heartbeats and a memory vault and markdown that I'm not updating. Well enough. And then what's going to happen is as these things work across the team and people understand these tools, you can start turning them into more shareable skills and plug-ins and extensions that make everyone's lives easier, not just yourself. And to be fair, if you use a lot of agents and tokens, I don't think it makes your life easier either. Yeah. And so if you've seen me give these talks in the past, I tend to think about these things in terms of three big acts, right? The first one is like, how do I bring the context into My agent. This might be contacts from my desktop, the browser. It might be from my mind and the mind of my coworkers and on Slack and email and all these things. Then it's about how you [5:00] How do you keep the work moving? How do you keep it organized? Because I can't even fit in my mind. And then lastly, how do you actually share that with the team? and level them up as well. So first let's gather the context. So if you go back to this example of maybe seeing some stuff online in my browser, the first thing I would do is take an app shot. As a show of hands, how many people have sent or used AppShots in the past? Nice. I'm trying to convert you today as well. So an app shot is a great way of sending context to ChatGPT. So what you do is if you just find the space bar, and there's going to be two command buttons on the side, I And it takes a screenshot. But not only does it take a screenshot, it takes the context of the entire app. any like metadata, any URLs, everything below the fold. And it's kind of the first time I felt like I could tag chat in any application I was in. Right. And at some point, I think like 30% of all the sessions I started In Codex, came from an app shop. It wasn't me opening the app into the empty composer, then thinking about, you know, please read Slack or please look at my browser. And AppTalk just kicks me off right where I am. And this is really the idea of just having an agent meet you where you are And tagging it, I think, is going to be a concept we think about a lot as we move forward. All right. The issue, though... is I'm still doing everything right now. I just use more apps and now I'm like the top three like app shot users of all time. And I'm still just like working until 2 or 3 a.m. in the morning. You take more app shots, you pin more threads, you name them, you set up another heartbeat automation, and then You know, if something else happens, you tell it to check Slack because it was like between your two hour automation I still feel like the bottleneck. And then after a meeting, I have to tell my agent there was a meeting so I can read more context. And, you know, this is my... This is my own punishment. Um, And ultimately, The issue was that I felt like I was very limited by my APM, my actions per minute. right and i just became a really really good micromanager But with dots. All these things are just very persistent and proactive and work in the background. If someone leaves a comment, sends an email, replies to a thread, my daughter is just waiting to soak up all that context. If someone shows a report online, we can just add it to a tracker. And then I don't have to worry about all these clues falling through the cracks. And a lot of this is because we've made our agents more persistent and more proactive, and especially more embodied. And this is because of the great work that research has done for things like memory and compaction and being able to run longer, as well as our product teams and just exposing more surfaces. And so let's also talk about what it means to be embodied in a couple of ways. Back to app shots. The issue is when I take an app shot, it's just my desktop context. But... The app is sent to the cloud. My dot runs in the cloud. It has its own computer. its own browser, its own files. And so it can run this investigation regardless of whether or not your computer is turned on. But it's nice that DotSail meets me where I am. It can still take the context from my laptop. And I can check up on it on the phone, in the browser, whatever it is. But working from your phone isn't necessarily new either, right? This is kind of like remote control. The difference is that... Dot, even though it runs in the cloud, it can still control my computer when I give it permissions to. This is like remote control on steroids. And so if you just enable it in your settings, your computer can still be the last mile of work for any of your agents in the cloud. The investigation can start on my computer. I can check up it on my phone. And at some point, it might say, hey, I need to log into a browser. Are you already logged in? Can I get access to your computer? Is there a local app that we need to check? Can I test it on your machine? And it can do that, which is pretty awesome. But that's just how dots can work with you as an individual. Right? But multiplayer is also thinking about how we can give a team context. or at least have the team give context to the agent. Right in the beginning you're just telling AI what to do As they get smarter and run for longer, you can now collaborate with the agents. that at some point your whole team should get involved. And so let's start with an example with voice. So I imagine most people here have tried some form of voice prompting, right? It is sort of the easiest way to prompt anything these days. And generally for most people, including me, I talk about three to four times faster than I type. And so... I see some nods. Maybe I'm talking too fast. But dictation is the first version of this, right? It's one directional. But then we introduce agentic voice, which is now two directional. Right? Whether it's on a mobile device or on a desktop app, I can now talk to it. It'll do some work in the background, it'll do some reading, and then it'll give me an update. And then I can tell it to ask me questions, help me brainstorm, and it's the first time I feel like a superhero, right? And it's the first time I think so many people have experienced like another wave of AGI. [10:00] but you're still kind of talking to yourself. But with chat to be meetings, for example, now these conversations are multidirectional. I'm prompting my coworkers, right? Where And more importantly... the conversations we have are gonna be transcribed and picked up by the dot in the background. I don't know if I'm ready for my dot to join the call and start chiming in. Just yet, Maybe we'll get there one day. But prompting the team is definitely important. Definitely useful. And the benefit of voice is just the fact that you can be incredibly messy and you can let the AI do all the cleaning up. This is like a real conversation I had over a meeting, but basically it was me and a couple of coworkers and it was just like, I think it might be guardian mode. I think I saw a Slack message from a guy whose first name starts with T. Can you also check the configuration for the feature flags, caching updates, and also compare some pull requests? I would have never typed any of that. I would have just taken the app shot and said, please investigate, and then just complain that the model is not doing a good job. But with all this rambling, I don't have to be the one taking notes, but I can know that these things are running in the background. But just like remote control, Like transcribing a meeting is obviously not new. The difference though, is that because we have a very persistent and proactive dot, it just picks up the meeting notes automatically. And it tries to push the work forward as long as you give it the permission to. Right. And it's just a much more natural way of working with my team, knowing that things can work in the background. And personally, I just find the voices to be nicer when I talk to humans than the AI. I see some of my coworkers here, and I think they all kind of know that. Like if we were ever in a meeting together, and there's a good idea for a blog post, or maybe like a script for a screenplay, or an ad, or even some copy for a product, I'll just like... prompt it in the middle of the call. Oh, that's a good idea. Let's turn it into a blog post. Please go draft something that we can review later. Okay, use this like new like screenplay tool to make some new timelines. Same with like wrapping up a meeting. At the end of a meeting, I'll give action items for my team and then even more action items for my agent. Please use my Slack connector to message these two people to see if they understand what's And when they reply, post back in the main Slack channel. You can use my browser to reach out to these four people online to ask them for their feedback IDs. Right. Really simple things. but I can just now trust that it's going to be working for me rather than now just realizing, all right, Thank you. open up the meeting, take another app shot, please review this meeting and reach out to the person, et cetera, et cetera. And this is sort of the advantage of persistence. right on top of this context. These conversations are also going to be happening outside of meetings, obviously. And this is where embodiment, again, really helps out. The conversations we have with my teammates ultimately become the prompts that we use for our agents that are running in the cloud. So earlier I said app shots feels like tagging a system. I'm tagging the agent to do something. We've also made these things a little bit more embodied by having them have different identities. So for example, if you use Slack or Teams, you can now just tag your dot. and ask her to follow up. You can have a long conversation with coworkers about some kind of design. Maybe you have a meeting about it. And you just go at Jason dot. Please investigate. And all of a sudden, I feel like the CEO who's just tagging people left and right. And you can have your dot and my dot and also team dots in the future. Right and again, we're gonna keep working towards like allowing these agents to meet you where they are So we're also gonna be launching even more surfaces in the future. I All right, we brought the contacts in through my voice, my co-workers voice, all these other plugins and maybe my browser. Now we have to actually Organize things. We have to make sense of it and make sure things are up to date. So earlier I mentioned that all this kind of worked for me as long as it was on my local machine. I had a bunch of automations. I had a bunch of different workflows. But what this really meant was, one, my team could not contribute. and two Now that we have way better cloud agents, I couldn't use any of it. And it was really hard for the entire team to start contributing because I sort of locked myself on my computer. But, Agents contributing on a single source of truth is the reason why software engineering has become so much more productive. But we really haven't had that for knowledge work just yet. I think we're slowly getting over these hurdles. So for this investigation, I might use a space. I'll tell my agent to create up a new page based off some template that I have. And then I can just share it with the team and the agents that they work with. And now I treat space as my local memory vault, but now it's in the cloud. And all I need to know is that as long as I tell Dot to keep track of these things and update the information, [15:00] - It's always going to be up to date. So then you say, OK, well, why did you use Markdown files originally? And the answer is directories and agent-md files are super useful. Right? All my automations ran in different threads, but with these H&MD files, I can at least guarantee that when they write to the thing, It's human readable, the citations are correct, the formatting is the way I want it to be useful. So with page instructions, you basically get that. You can effectively define agent MD files for your documents. And so as you do things like having custom artifacts, or embedded HTML and visualizations, Your agents empty file can define how these things are going to be updated by your agents, whether it's an automation or anything else. And that way, all your coworkers, agents can now contribute without making a mess of what's going on. Thank you. For this reason, Space, maybe it's a really simple automation. Maybe I just have a couple of dots contribute to just updating Slack posts and leaving comments about what feedback IDs we've captured. But automations can also be defined not at the level of your dot, but also at the level of a page. or a team if you create a team. in Chatsapult. So for example, we have a finance team and they do these weekly analytics reports. And this is done by a cloud agent that updates this document, and is connected to all the things you have enabled in the cloud. For engineering, simple things could be Organizing all your pull requests and the scope of these projects and just figuring out who the DRI is and just knowing you have a single page to review all the things that need to get merged. For research, it's about just tracking long-running experiments, and for me, I basically use this to delegate most of my work for Dev Day. whether it's this talk and the slide updates, the booths that you see outside, or even like the mod retro. And basically, it was able to capture all the different work that I had delegated. And ultimately, the goal for me was to not be distracted by Slack, because, you know, obviously, Some of these things come in pretty late. All right, you have the context. You keep it moving with all these automations. Now you have to actually do something with it and share it with the team. You've got to share out the results. So ideally, if we did our jobs correctly, we'll have a single space that has a timeline of what's going on, the reports, feedback IDs that we've been collecting online, and just hopefully links and citations to all these conversations so we know what to believe in. Now we have a hypothesis, and obviously I can just point a cloud agent at it, and it can go reproduce the issue. investigate the issue and try to solve this. You know, it's part of the conversation we have on Slack. Maybe we decide on what the comms look like to let everyone know that things are back online. And ideally, no one has to be the glue. And we can just make better informed decisions rather than just scrambling to understand when this was addressed. But if you've been on call before, you know that a pull request isn't like the final thing that you deliver. You have your postmortems, your presentations, your blog posts. And I imagine for these things, you probably already have a bunch of different skills for comms or design. But all these things are mostly instruction-based plugins. Right? Like if you think about rules and automations as a way of keeping the work moving and up to date, plugins and extensions are sort of the next step with that journey. Plugins are both shareable. and updatable and versioned. So as you make improvements now, they can just be widely distributed to the rest of your team. With things like plugin extensions, you can build custom interfaces directly in the Codex app. Now it can be your cockpit for everything. our meetings product, and our code review product are all built on the same components. as plugins. For example, if you build a lot of sites, you can now have better tools to log in with ChatGPT and connect your connectors, But on top of that, sites can now also serve MCP servers. with authentication. And also, with WebMCP, you can build tools that both a person and the AI can use together. And these give you a ton of new capabilities to expose to your team as you invest in this infrastructure. So And I think for the most part, like we're all the early adopters. Right. And as these technologies come in, we're mostly asking ourselves, like, what can I do with these tools? But I think the next stage is not going to be just about using more agents or more tokens. It's about how we can invest in these systems so that the automation and the plugins and these skills are shared across the team and it becomes a team responsibility. How do I set up my agentic infrastructure for the team and become the plugin hero of the company? I think if you're at Dev Day, it's probably you. But I think that's a pretty good place to be. And so I talked about this engineering use case, but obviously, like, it's not just engineering, right? I use my dots and my space to manage a bunch of different things like production shoots, content planning with the team, and it's pretty fun. So for example, like when I do a lot of these [20:00] as we shoot launch videos, for example. I'm just on set, really scrambled. But my dot keeps me up to date. It will update me during the breaks. I try to give it some ambitious tasks on how to unblock itself. And it tries to keep everything up to date. And so if I have like 10 minutes to spare, I just read the, you know, Update. and everyone else can see it. Then I can make things like different kinds of sites or documentation changes just based on the feedback and the approval process. Um, And if I have very little time, I just... Call it. And we can use voice as a faster way of communicating. Another example I use a lot is just when I'm doing a lot of content planning. So with the creative team, with the marketing team, we're always just brainstorming on Slack or in a meeting. And it just keeps me accountable, right? It doesn't let me let good ideas slip through the cracks. And so as a result, I've built way more skills and plugins and websites just to do more like prototyping. Because now I know if there's a good blog post idea or a launch video, I can just like, Shout it into the ether And at some point in the future, my dot will just give me a message to a site or a presentation or a website that just gives an idea of like how we should do this ad or maybe how we should think about the launch process. And I think for the first time in a couple of months, really, These automations now are the ones that are giving me my attention back. Right. And as a result, I can sort of work with my coworkers a little bit more, Think a little bit bigger and be a little bit more ambitious. Thank you. But one thing you'll hear me talk about a lot today is just the fact that it's really nice to work with other people. uh... Maybe those are some disagreements, but-- My guys are pretty nice. And the more my team can help me with this work and push it forward and pick up where I left off, the more I feel like I'm working on a team again for the first time in a while. And this is a really great feeling. Because I think in 2026 – I think it's so easy to feel like you can just walk in with your coding agent and work until 3 a.m. in the morning. But that's just personally not very fun to me. I joined a company so I could work with great people and figure things out together. And the more I do this process, the more I think about that line, which is, I want AI to do my laundry and wash my dishes so I can make art. And I'm definitely fully seeing that, right? Or at least the work that feels like laundry and the work that feels like the dishes and the work that feels like the art. And so in the past couple of months, I've actually been able to spend even more time worth research and creative and product and marketing and having like more fun that I did before I was just like in the cave. And so I think if you feel the way I do, I really encourage you to try these tools out for yourself and really think about bringing in more collaboration. in the work that you do. Thank you. Thank you. .