OpenAI Launches WebMCP Standard to Let AI Agents Control Web Apps

Sites and the Next Generation of Web Apps | DevDay 2026 — OpenAI

OpenAI

By exposing programmatic backend tools directly to AI agents, the new WebMCP standard makes agentic web browsing faster and cheaper than traditional vision-based computer use.

AI-assisted summary of Sites and the Next Generation of Web Apps | DevDay 2026 — original source. Check the original for full context.

Source published:

Key ideas

  • OpenAI's Sites platform has scaled to over 8 million hosted web applications externally, with over 70% of OpenAI employees actively building on it internally. (0:20)
  • Sites officially launched Scheduled Tasks alongside embedded SQLite databases, allowing applications to synchronize data automatically via plugins without triggering code rebuilds or redeployments. (4:22)
  • Through 'Sign-in with ChatGPT' and client plugin forwarding, hosted Sites dynamically load each authenticated user's private third-party data—such as Linear tickets or Slack history—with zero custom API integration. (5:56)
  • OpenAI introduced WebMCP, a browser standard that lets AI agents interact with web applications via exposed programmatic tools instead of slow and brittle vision-based clicking. (14:22)

Detailed notes

## Background Published by OpenAI on YouTube on November 11, 2026, this DevDay session introduces Astra, ChatGPT Sites, and WebMCP. According to the page description, the presentation demonstrates how to transform ideas into interactive web experiences while building new kinds of collaborative interfaces alongside colleagues and AI agents.

## TL;DR OpenAI's Katia and John showcase the evolution of ChatGPT Sites from an internal deployment hack into a hosting platform powering over 8 million sites with deep adoption across technical and non-technical teams. Through live demonstrations, they show how simple natural language prompts generate full-stack applications complete with embedded SQLite storage, scheduled background syncs, and native ChatGPT authentication that automatically personalizes data using viewers' individual plugin connectors. John highlights HTML-native annotation tools that allow collaborators to prompt Codex to safely modify live UI components, while Katia debuts a consumer gift application powered by WebMCP. Rather than relying on fragile vision-based scraping, WebMCP allows autonomous agents to invoke programmatic website endpoints directly, establishing an agentic web optimized equally for human browsing and autonomous agent interaction.

## Atmosphere & style The presentation delivers a crisp, pragmatic developer-conference vibe marked by effortless tag-team chemistry between Katia and John. Grounded by relatable anecdotes about internal engineering friction, the session builds an engaging, hands-on momentum through live coding and browser demonstrations where real-time prompts generate functional software before the audience's eyes. It feels candid, tech-forward, and casually confident, demystifying complex architectural concepts like agent tool-calling and zero-trust auth into approachable, practical daily workflows.

## Bulletin - [00:20](https://www.youtube.com/watch?v=QRm7VNMnurA&t=20s) OpenAI's Sites platform has scaled to over 8 million hosted web applications externally, with over 70% of OpenAI employees actively building on it internally. - [04:22](https://www.youtube.com/watch?v=QRm7VNMnurA&t=262s) Sites officially launched Scheduled Tasks alongside embedded SQLite databases, allowing applications to synchronize data automatically via plugins without triggering code rebuilds or redeployments. - [05:56](https://www.youtube.com/watch?v=QRm7VNMnurA&t=356s) Through 'Sign-in with ChatGPT' and client plugin forwarding, hosted Sites dynamically load each authenticated user's private third-party data—such as Linear tickets or Slack history—with zero custom API integration. - [14:22](https://www.youtube.com/watch?v=QRm7VNMnurA&t=862s) OpenAI introduced WebMCP, a browser standard that lets AI agents interact with web applications via exposed programmatic tools instead of slow and brittle vision-based clicking.

## Key takeaways - [00:20](https://www.youtube.com/watch?v=QRm7VNMnurA&t=20s) Sites began as an internal engineering hack to deploy full-stack apps directly from Codex without slow infrastructure friction, eventually spreading across non-technical company departments. - [00:20](https://www.youtube.com/watch?v=QRm7VNMnurA&t=20s) Over 70% of OpenAI employees build on Sites, using it to replace static slide decks and spreadsheets with interactive dashboards and operational tools. - [02:26](https://www.youtube.com/watch?v=QRm7VNMnurA&t=146s) Codex can transform raw spreadsheets into multi-view interactive applications (list, Kanban board, calendar) using custom UI design system libraries from a single natural language prompt. - [04:22](https://www.youtube.com/watch?v=QRm7VNMnurA&t=262s) Plugins serve as unified connectors allowing Codex and ChatGPT to interface directly with external platforms like Google Drive, Linear, Slack, and GitHub without bespoke webhook scaffolding. - [04:22](https://www.youtube.com/watch?v=QRm7VNMnurA&t=262s) Each Site comes with an embedded, zero-configuration SQLite database that decouples background data syncs from code rebuilds and deployments. - [04:22](https://www.youtube.com/watch?v=QRm7VNMnurA&t=262s) Scheduled Tasks for Sites enables recurring background loops (hourly, daily, or weekly) to automatically refresh application data dependencies. - [05:56](https://www.youtube.com/watch?v=QRm7VNMnurA&t=356s) Sites defaults to a zero-trust posture powered by 'Sign-in with ChatGPT', intercepting unauthenticated traffic before the site payload loads. - [05:56](https://www.youtube.com/watch?v=QRm7VNMnurA&t=356s) Client-side plugin forwarding allows visitors to bring their personal ChatGPT plugin credentials into a Site, enabling personalized data views and read/write capabilities per user. - [07:26](https://www.youtube.com/watch?v=QRm7VNMnurA&t=446s) Workspace permissions like 'Editor' allow designated team members to prompt Codex directly to push collaborative modifications to production code. - [11:05](https://www.youtube.com/watch?v=QRm7VNMnurA&t=665s) Annotation extensibility embeds suggested prompts and component options directly into HTML markup, establishing safe guardrails for Codex modifications. - [14:22](https://www.youtube.com/watch?v=QRm7VNMnurA&t=862s) Sites supports secure server-side environment variables, allowing full-stack web applications to safely call APIs such as the OpenAI Image API. - [14:22](https://www.youtube.com/watch?v=QRm7VNMnurA&t=862s) WebMCP establishes a structured tool execution standard for in-browser agents, replacing expensive and fragile vision-based scraping or automated clicking. - [14:22](https://www.youtube.com/watch?v=QRm7VNMnurA&t=862s) User agents operating over WebMCP can safely reference personal context across internal tools (like Slack DMs) to automate external web interactions while keeping humans in the loop. - [19:13](https://www.youtube.com/watch?v=QRm7VNMnurA&t=1153s) Sites automatically formats and exposes WebMCP endpoints in application logic, enabling developers to build sites optimized for both human users and AI agents.

## Detailed walkthrough ### [00:20](https://www.youtube.com/watch?v=QRm7VNMnurA&t=20s) The Origin and Viral Internal Adoption of Sites

Katia from Developer Experience and John, the lead engineer for Sites, introduce the session by reframing what Sites actually is. While originally launched earlier in the year as a simple web hosting service, John reveals that it began as an answer to his personal engineering friction. When he initially joined OpenAI to build internal web applications for researchers, deploying full-stack tools into OpenAI's production infrastructure was slow and frustrating. To fix this, he hacked together an internal prototype that allowed engineers to spin up and deploy full-stack web applications straight from Codex.

The tool caught fire inside the company. What began as a prototype passed among software engineers quickly crossed over to non-technical teams, sparking an organic, company-wide wave of app creation. A dedicated team was formed—several of whom were sitting in the DevDay audience—and Sites was officially shipped as a product just a few months later. John shares striking adoption metrics: within months of launch, Sites is already hosting 8 million sites externally, while internally at OpenAI, over 70% of employees actively build their own. Teams across go-to-market, IT, product management, design, and engineering use it to replace static slide decks with interactive presentations, transform spreadsheets into tailored UIs, jam on creative ideas, deploy production workflows, and build bespoke games without sweating infrastructure details.

As John puts it: > “At OpenAI, there's now a site for everything.”

- **Hosting Scale**: Over 8 million Sites hosted within months of external availability. - **Internal Saturation**: Greater than 70% of all OpenAI employees have built their own Sites. - **Primary Use Cases**: Ideation, interactive presentations instead of slide decks, custom spreadsheet replacements, team-bespoke operations tools, rapid prototyping, and games. - **Session Roadmap**: Katia outlines the three stages of the presentation: generating a site from a single natural language prompt, layering in collaborative and personalized features, and finally making the app agent-friendly.

---

[02:26](https://www.youtube.com/watch?v=QRm7VNMnurA&t=146s) Transforming a DevDay Launch Tracker from a Spreadsheet into a Site

Katia transitions to a live demonstration on her laptop to illustrate how OpenAI teams manage projects using Sites. She displays an internal Google Sheet used by the team to track DevDay launches. While functional for high-level overviews—containing columns for launch features, statuses, milestones, and links to drive briefs—she points out that spreadsheets are visually boring, awkward to parse for granular project updates, and difficult to navigate when deep-diving into individual launch assets.

To upgrade this workflow, Katia captures the sheet and prompts Codex to construct an interactive "Launch Radar" web application inside a new folder and publish it directly as a Site. In her prompt, she specifies using their shared DevDay UI design system library, presenting launch items on the first screen with milestones and attention-needed indicators, providing filterable controls by product area, and implementing multiple layout modes including list, board, and calendar views with direct hooks into underlying project documentation and assets. To ensure the application does not become stale, she issues a follow-up instruction asking Codex to automatically update the site every morning by scraping the detailed launch briefs in Google Drive referenced within the spreadsheet.

```mermaid flowchart TD accTitle: Spreadsheet to Automated Site Flow accDescr: A diagram illustrating how raw sheet data and briefs are transformed into an interactive site via Codex, scheduled tasks, and plugins.

subgraph DataSources["Data Sources"] A["DevDay Launch Spreadsheet"] B["Google Drive Launch Briefs"] end

subgraph CodexEngine["Codex & Infrastructure"] C["Codex Site Generator"] D["Scheduled Task (Daily Cron)"] E["Drive & Linear Plugins"] F[("Embedded SQLite DB")] end

subgraph Output["Hosted Web Application"] G["Interactive Launch Radar Site\n(List / Board / Calendar Views)"] end

A -->|"Prompt + DevDay UI Library"| C C --> G B --> E D -->|"Daily Sync"| E E -->|"Direct Write (No Redeploy)"| F F --> G ```

---

[04:22](https://www.youtube.com/watch?v=QRm7VNMnurA&t=262s) Keeping Sites Fresh: Plugins, SQLite, and Scheduled Tasks

While the application compiles and deploys live, John steps in to explain the underlying mechanics that keep Sites continuously synchronized with enterprise data: plugins and scheduled tasks. Plugins serve as unified bundles of connectors and operational skills that allow ChatGPT and Codex to authenticate and interact with external third-party software environments. Rather than requiring bespoke webhook scaffolding or custom API glue code, plugins allow Codex to perform actions such as inspecting Linear backlogs, querying Slack communication channels, reading Google Drive repositories, or publishing pull request comments onto GitHub repositories.

To solve the freshness problem, OpenAI combines plugins with scheduled execution loops and native data storage. Users can establish recurring background tasks directly within their conversational thread, setting Codex to refresh an app on an hourly, daily, or weekly cadence. When a task triggers, Codex runs the relevant plugin to retrieve updated assets. Because every Site includes a zero-config, embedded SQLite database out of the box, data updates write straight to SQLite without modifying the application source code or triggering a rebuild and redeployment cycle. As part of DevDay, John announces that Scheduled Tasks for Sites is officially launching, giving users unified lifecycle management where Codex automatically recognizes dynamic data dependencies and proactively suggests automated refresh schedules.

John summarizes the core architectural benefit of decoupling data writes from app deployments: > “The task will update the database directly, updating the site instantly, skipping the need to redeploy.”

---

[05:56](https://www.youtube.com/watch?v=QRm7VNMnurA&t=356s) Auth Architecture and Personalized Views via Client Plugins

John shifts the discussion to access control and data personalization for end users. Sites comes equipped with native authentication powered directly by "Sign-in with ChatGPT." While applications can be toggled public with an optional anonymous landing page and a secondary ChatGPT sign-in button for gated features, every newly created site defaults to strictly private. In this zero-trust posture, unauthenticated visitors are intercepted before reaching the application payload, authenticated via their ChatGPT identity, verified against the access list, and passed through into the authenticated session.

Beyond gatekeeping, John introduces a major feature launching that day: client-side plugin forwarding. When team members log into a private Site using Sign-in with ChatGPT, they bring their personal ChatGPT plugin credentials with them into the hosted web application. This architecture means that rather than all users viewing a generic static dashboard, the application dynamically pulls contextual data mapped to the logged-in user's identity across tools like Google Drive, Slack, Linear, or internal bespoke corporate connectors. If Katia loads the dashboard, the interface queries Linear through her credentials to present her assigned issues; when John visits the identical URL, the interface queries through his connectors and loads his unique assignments instead.

```mermaid flowchart LR accTitle: Authenticated User Personalization Architecture accDescr: Flow diagram showing how Sign-in with ChatGPT enables personalized plugin data loading per user on the same Site.

subgraph AuthBarrier["Sign-in with ChatGPT"] U1["User: Katia"] U2["User: John"] GW{"Auth & Plugin Check"} end

subgraph PrivateSite["Hosted Private Site"] APP["Launch Radar Web App"] end

subgraph UserDataSources["Third-Party Connectors"] L1["Katia's Linear Tickets"] L2["John's Linear Tickets"] end

U1 --> GW U2 --> GW GW -->|"Authenticated Session"| APP APP -->|"Katia's Token"| L1 APP -->|"John's Token"| L2 ```

---

[07:26](https://www.youtube.com/watch?v=QRm7VNMnurA&t=446s) Live Deployment, Workspace Permissions, and Validating Linear Data

Katia returns to her terminal thread to add this personalization layer into the newly built Launch Radar. She submits a prompt instructing Codex to integrate the Linear connector with both read and write capabilities, display each team member's assigned tickets right alongside relevant DevDay launch tracks, and allow users to modify ticket descriptions or advance task statuses directly from the Site UI back to Linear's database.

While the updates compile, Katia opens the initially requested application in full screen. In just a few minutes, Codex generated a complete web app utilizing OpenAI’s internal DevDay design system, featuring toggleable calendar, Kanban board, and list views, milestone cards, and linked assets extracted from the spreadsheet. Katia points out that this workflow is not an artificial stage demo; internal teams used these exact automated Sites to coordinate the DevDay launch itself. She demonstrates sharing permissions by searching for John and granting him "Editor" access—explaining that Editor status permits authorized workspace peers to push code updates to the production deployment.

Katia emphasizes how low the barrier to entry has become for anyone wanting to deploy software: > “So whether it's for yourself, your team, or to share an idea publicly in just a few minutes with zero, you know, zero skills or knowledge needed, you can just prompt it and have a link that you can share.”

She checks the app's settings panel, verifying that the daily scheduled sync with Google Drive has successfully linked. By the time she completes the permission walkthrough, the Linear connector implementation finishes deploying. Opening the live site, the ChatGPT authentication layer instantly recognizes her account and populates the dashboard with her personal Linear tickets without requiring manual API configurations or local environment setups, setting up the handoff to test John's personalized view.

[11:05](https://www.youtube.com/watch?v=QRm7VNMnurA&t=665s) Collaborative Sites, Linear Connectors, and Custom Annotations

When John Abrams switches over to present his screen, he accesses the exact same site, but it immediately renders personal context tailored to his account: it displays his own Linear tickets. The application fetches this data on load using John’s pre-existing Linear connector in ChatGPT. There is no need to write third-party integrations, manage API keys, read external API documentation, or configure bespoke user permissions, because ChatGPT Sites leverages each authenticated user's connectors directly out of the box. John tests the site's write permissions by opening a ticket marked "Canceled," changing its status to "In Progress," and saving it directly back to Linear.

```mermaid flowchart LR accTitle: User Connector and Annotation Workflow accDescr: Diagram showing how ChatGPT Sites loads personal connector data and commits design edits via Codex. subgraph PersonalContext["User Context"] A["User loads Site"] --> B["ChatGPT Linear Connector"] B --> C["Personal Tickets Loaded"] end subgraph AnnotationLoop["In-App Browser Custom Annotations"] D["Select UI Element"] --> E["Preview Component Variant"] E --> F["Send instruction to Codex"] F --> G["HTML & Codebase Updated"] end ```

To modify the application itself, John turns to the ChatGPT in-app browser’s annotation tools, highlighting a newly launched feature called annotation extensibility. This allows web developers to embed custom annotation controls directly inside a site's HTML markup, providing guidance and guardrails for Codex. Developers can define suggested prompts and custom visual selectors within their design systems and component libraries so that collaborators understand exactly what can be modified. Demonstrating this live, John selects an "Edit UI" button, activates annotation mode on a status bar that might be difficult for audience members in the back of the room to read, and previews an enlarged variant before handing the edit off to the model:

> “Codex is grinding away on it.”

- **Zero-Setup Integrations**: Sites automatically inherit the viewer's active ChatGPT connectors (such as Linear), eliminating integration boilerplate and token configuration. - **HTML-Native Signals**: Custom annotations live right in the web app's HTML code to supply suggested prompts and component options to Codex. - **Collaborative Site Editing**: “If you share a site meant to be edited by other people, this makes contributing much easier,” making component design systems approachable for non-technical team members.

---

[14:22](https://www.youtube.com/watch?v=QRm7VNMnurA&t=862s) Gift Studio, WebMCP, and Agentic Browser Interaction

While internal organizational dashboards demonstrate personalized team workflows, Sites also supports public-facing full-stack consumer applications. To show this, Katja introduces *Gift Studio*, a bespoke web app created with Sites to design a custom commemorative gift box for John. The app connects to the camera, snaps a photo, and sends it to OpenAI’s newest image model via the OpenAI Image API to generate a personalized box design. Because Sites supports secure server-side environment variables, developers can store OpenAI API keys or any third-party credentials just as they would in any traditional production stack.

```mermaid flowchart TD accTitle: WebMCP Tool-Based Architecture accDescr: Flow comparing direct WebMCP tool calling versus traditional vision-based computer use. subgraph WebMCPFlow["WebMCP Browser Execution"] Agent["User Agent"] -->|"1. Inspect DMs"| Slack["Slack Integration"] Agent -->|"2. Invoke exposed WebMCP tools"| SiteBackend["Site API / Backend"] SiteBackend -->|"3. Direct DOM/State Update"| LiveUI["Live Gift Studio UI"] end subgraph Collaboration["Human In The Loop"] User["User Katja"] -->|"Adjust budget (<$100)"| LiveUI end ```

Rather than manually browsing the product catalog to fill the gift box, Katja leverages WebMCP, a browser standard allowing AI agents to interact with websites through structured programmatic tools rather than raw browser automation. Unlike vision-based "computer use"—which forces an agent to visually click through buttons, open individual modals, and scrape rendered metadata—WebMCP allows the agent to call the site's exposed backend tools directly, making tasks faster, more reliable, and significantly cheaper. Because the user's agent carries context across personal tools, Katja asks it to check her direct messages with John on Slack, deduce his interests, and query the catalog via WebMCP:

> “WebMCP is a new browser standard that lets your agent interact with the site via exposed tools.”

- **Agent Tool Execution**: WebMCP exposes application endpoints directly to the agent running within the ChatGPT in-app browser. - **Data Privacy & Context**: The user's personal agent references connected workspace apps (e.g., Slack history showing John loves his dog) to populate the third-party app with curated recommendations (dog toys). - **Human-Agent Collaboration**: The user retains full control to inspect, add, or delete items within the visual UI—Katja removes items to keep the total expense under $100. - **Automated Messaging**: Prompting ChatGPT with the request to draft a note based on prior conversations fills the site's input field without requiring tedious manual typing.

---

[19:13](https://www.youtube.com/watch?v=QRm7VNMnurA&t=1153s) The Future of the Agentic Web

Katja and John conclude by framing WebMCP and Sites as the foundation for the next generation of web applications, where human users and their personal software agents browse the web together. Developers building on Sites do not need to construct WebMCP interfaces manually from scratch; the Sites plugin automatically structures and exposes WebMCP-compliant endpoints wherever relevant in the application logic.

> “As we evolve towards a world where users bring their agents with them to navigate the web, you can adapt by building your apps in a way that works well with agents.”

Modern Sites combine automatic server scaling, integrated authentication, and managed databases with agent-friendly capabilities: - **Teammate Data via Connectors**: Applications dynamically personalize data using plugins without requiring separate authentication flows or API tokens. - **Dual Optimization**: Web applications are constructed to serve both human users clicking on a display and autonomous agents executing tool payloads under the hood. - **Custom Annotations**: Embedded component hints make it seamless for human editors to direct AI coding agents to adjust live production designs safely.

## Notable quotes > [19:13](https://www.youtube.com/watch?v=QRm7VNMnurA&t=1153s) As we evolve towards a world where users bring their agents with them to navigate the web, you can adapt by building your apps in a way that works well with agents. — Katja and John

## Mentioned OpenAI, Astra, ChatGPT, ChatGPT Sites, WebMCP, Codex, John Abrams, Katia, Google Sheet, Google Drive, Linear, Slack, GitHub, SQLite, Gift Studio, OpenAI Image API

## Video description Turn an idea into an interactive web experience with Astra, ChatGPT Sites, and WebMCP. Learn how to build new kinds of interfaces alongside your colleagues and agents.

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

Reading summary

At DevDay 2026, OpenAI presented Sites as a platform for deploying full-stack, automated web applications from natural language prompts, arguing that modern web development is transitioning toward software designed for both human interaction and AI agent tool use. Internal Prototype to Mass Adoption (0:20) Sites originated as an internal hack created by lead engineer John to bypass slow production infrastructure when deploying web apps for OpenAI researchers. The prototype spread across technical and non-technical teams, prompting OpenAI to formalize it into a dedicated product. According to John, more than 70% of OpenAI employees have built their own applications, using Sites to convert spreadsheets into interfaces, replace slide decks with interactive presentations, and spin up operational tools. Externally, the service reached over 8 million hosted sites within months of release. Decoupled Data Architecture and Scheduled Tasks (2:26) Sites handles enterprise workflows by separating application deployments from background data refreshes. To demonstrate this, Developer Experience engineer Katia prompted Codex to convert an internal Google Sheet and Google Drive launch briefs into a 'Launch Radar' application, complete with milestone indicators and multiple layout views based on OpenAI's internal UI library. Rather than requiring custom webhooks or manual redeployments, Sites provides every application with an embedded SQLite database. Connectors and plugins allow Codex to read and write to third-party tools such as Google Drive, Slack, and Linear. Through newly introduced Scheduled Tasks, developers configure Codex to poll external sources and write updates directly into SQLite on hourly, daily, or weekly cadences without triggering code rebuilds. Sign-in with ChatGPT and Personalized Views (5:56) Sites defaults to a private access model governed by 'Sign-in with ChatGPT,' intercepting unauthenticated traffic before the application payload loads. A core feature announced at the event is client-side plugin forwarding: when authenticated users log into a private Site, the application inherits their personal ChatGPT connector credentials rather than relying on global API keys. In a live demonstration, the same dashboard URL loaded Katia's Linear tickets when she logged in, and automatically rendered John's assigned tickets when he opened the link. Users can also execute writes directly back to third-party databases, such as updating task statuses. Collaborative Editing via In-Markup Annotations (11:05) To streamline modifications across mixed-discipline teams, Sites introduced annotation extensibility inside the ChatGPT in-app browser. Developers can place custom annotation attributes directly within a site's HTML markup and component design systems. These tags provide Codex with suggested prompts and visual component variants, creating guardrails so non-technical collaborators can point to interface elements, preview modifications, and instruct Codex to safely commit changes to the production codebase. Agent-Ready Web Apps via WebMCP (14:22) Beyond internal dashboards, Sites accommodates consumer applications equipped with backend environment variables and API integrations, illustrated by Gift Studio, a demonstration app using OpenAI's Image API to generate custom gift box designs. Rather than relying on vision-based computer control that requires scraping pixels and simulating mouse clicks, Sites leverages WebMCP, an emerging browser standard that exposes structured backend tools directly to AI agents. Running inside the ChatGPT browser, an agent can check personal context across tools—such as inspecting Slack direct messages to identify a recipient's interests—and invoke exposed WebMCP endpoints to search catalogs and fill shopping carts reliably and cheaply. Human users maintain oversight, retaining the ability to modify parameters, adjust budgets, or edit drafted text within the visual interface. OpenAI projects that future web applications will operate under a dual-optimization model, requiring interfaces that serve both direct human interactions and programmatic agent tool calls via standards like WebMCP.

Source quotes

[19:13] Katja and John: As we evolve towards a world where users bring their agents with them to navigate the web, you can adapt by building your apps in a way that works well with agents.

Original transcript

[0:20] Hi, everyone. [0:21] I'm Katia, and I'm on [0:22] the Developer Experience team. [0:24] Hi, everybody. [0:25] I'm John, and I'm [0:26] the lead engineer for Sites. [0:27] You may know Sites as a web [0:29] hosting service that we launched earlier [0:31] this year, but it's actually way more [0:33] than that, and this is what we're [0:35] going to be talking about today. [0:36] I initially joined OpenAI to work on [0:39] internal web apps for researchers, [0:41] but I found it really frustrating [0:43] to deploy those tools within [0:45] our OpenAI infrastructure, [0:46] so I prototyped an easier way [0:49] to deploy those full-stack web apps [0:51] within the company directly from Codex. [0:53] The prototype got passed around by [0:55] other engineers, then surprisingly [0:56] non-engineers started adopting it, [0:59] and apps just started spreading [1:01] throughout the company. [1:03] Then we formed a team. [1:05] Some of those team members are [1:06] in this audience right now. [1:08] And then a few months later, [1:09] we shipped Sites. [1:11] Now, even though Sites only [1:13] shipped a couple months ago, [1:16] we're already hosting 8 million Sites. [1:19] And here at OpenAI, over 70% [1:22] of employees are making their own Sites. [1:25] Some of the most common use cases [1:27] are jamming on ideas with others, [1:29] replacing slide decks with more [1:31] interactive presentations, [1:33] replacing spreadsheets with dedicated [1:35] UIs, creating all sorts of internal [1:37] tools bespoke for each team. [1:39] Go to market, IT, PMs, designers, [1:42] and engineers like myself, [1:44] we're all building elaborate [1:45] prototypes, production tools, [1:47] and I'm personally really excited [1:49] for games, and then we share those [1:52] without sweating the details. [1:54] At OpenAI, [1:55] there's now a site for everything. [1:56] Yeah. [1:57] And what we're observing is that since [1:59] Sites connects to your context, [2:01] plug-ins, and agents running [2:03] into HGPT, it makes it super easy [2:05] to create personalized software [2:07] and collaborative experiences, both [2:10] for internal and external use cases. [2:13] So here's what [2:14] we're going to show you today. [2:15] We're going to show you how you can [2:16] build a site from a single prompt, [2:19] then how you can make it collaborative [2:21] and personalized, and finally, [2:23] how you can make it agent friendly. [2:26] So as John mentioned, we use Sites [2:28] all the time internally to turn [2:30] team data into interactive apps. [2:33] So let me show you a real-life [2:35] example on my laptop. [2:40] Okay. [2:40] So in our team, we have this spreadsheet [2:42] that we've been updating regularly [2:45] to keep track of Devday launches. [2:48] It has context on the several [2:50] things that are launching at Devday [2:51] with the progress on each project, [2:53] and then links to other [2:55] assets and documents. [2:57] So this is a good way of seeing [2:59] at a glance what's happening at a high [3:00] level, but it's not super practical [3:03] to get details on each project. [3:05] And it's also a bit boring [3:06] to look at, to be honest. [3:07] So let's first turn this into [3:09] a site, and then we'll make [3:11] sure that it stays fresh. [3:12] So let me upshot this. [3:15] And then I am going to ask [3:18] Codex, can you turn this sheet into [3:21] a launch radar app in a new [3:24] folder and then publish it as a site? [3:26] You can use our shared Devday [3:28] UI library and Sites system. [3:30] And I want you to show milestones, [3:32] what needs attention, [3:33] with launches visible [3:34] on the first screen. [3:35] And then let me filter by product [3:37] area, switch between different views, [3:40] list, board, and calendar, and then open [3:42] each launch's docs and assets. [3:46] Great. [3:47] So I'm sending this. [3:49] So Codex is going to start building [3:50] a site based on this spreadsheet. [3:53] But what we want is to keep [3:55] it up to date automatically [3:56] based on these documents I [3:58] have in my drive that detail [4:00] everything that is launching. [4:02] So I'm just going to ask Codex, [4:04] can you keep this site up [4:06] to date every morning using the launch [4:08] briefs linked from the sheet? [4:11] Great. Let's send that. [4:12] And so behind the scenes, this is going [4:14] to use plugins and scheduled tasks. [4:17] So while this is building live, John [4:19] is going to explain what they are. [4:22] All right. [4:23] So I'm sure everybody's been [4:26] hearing a lot about plugins today. [4:28] Well, there's something that we [4:29] launched a little while ago. [4:31] And they're the way that ChatGPT [4:34] and Codex bundles both connectors [4:37] and skills so that Codex [4:40] and ChatGPT can access your data [4:43] from third-party services. [4:45] So for example, [4:48] it lets Codex read which tasks [4:50] are assigned to you in linear. [4:51] It can search through your Slack [4:53] messages or even post PR comments [4:55] in GitHub on your behalf. [4:57] Codex can already use your plugins [4:59] to fetch your up-to-date data [5:01] and then update your site. [5:03] If you combine [5:04] that with scheduled tasks, [5:06] Codex can keep your site up-to-date [5:07] even while you're asleep. [5:09] Now, you can schedule [5:10] a task directly from your thread. [5:12] You can ask Codex to keep [5:13] your site up-to-date every hour, [5:15] every day, every week. [5:17] You tell it to fetch your data [5:18] from whichever plugin has the data. [5:20] For example, we just [5:22] asked it to use Google Drive, [5:23] and then the plugin will be used [5:24] to fetch those relevant docs. [5:27] Now, Sites also comes [5:29] with a SQLite database. [5:31] So there's no need to change [5:32] the site's source code when the data [5:34] that the site is showing changes. [5:37] The task will update [5:38] the database directly, [5:40] updating the site instantly, [5:42] skipping the need to redeploy. [5:44] And one thing we're launching today [5:45] is scheduled tasks for sites. [5:48] Now, your tasks and sites can be [5:49] linked for easier management, and Codex [5:51] will know to suggest scheduling [5:53] when it's relevant for your site. [5:55] All right. [5:56] So now that our site has up-to-date [5:57] info, let's think about [5:59] what the site's viewer sees. [6:01] As you may know, Sites has built-in [6:03] auth, powered by Sign-in with ChatGPT. [6:06] Now your site can be made publicly [6:08] available on the internet, along [6:10] with a landing page for anonymous users, [6:12] and you can also add a link [6:14] that lets the users sign in to ChatGPT, [6:17] enabling additional functionality, [6:19] just like a standard web app. [6:20] But before you do that, before you [6:22] publish your site onto the internet, [6:24] all new sites are private by default. [6:27] When a site is private, [6:28] we make sure only the intended [6:30] people can access the site. [6:31] And the way we do that is [6:32] with Sign-in with ChatGPT. [6:34] So you go visit the site. [6:35] Before you even get to the site, [6:37] you have to sign in. [6:37] We check that you are [6:39] who you say you are. [6:40] And then we allow you through. [6:42] And then you end up on the site [6:43] already signed in. [6:44] And starting today, teammates [6:47] that sign into your private sites can [6:49] also bring their plugins from ChatGPT [6:52] to the site that they're visiting. [6:54] With plugins and Sites, [6:56] your site can directly access [6:57] your teammates' data from services [6:59] like Drive, Slack, and Linear. [7:01] This also works great with any [7:03] of your team's internal-only connectors. [7:06] The idea is that if Katja visits [7:09] a site that has plugins implemented, she [7:11] can see her own data that is [7:13] fetched when she first loads the page. [7:15] And then when I go visit [7:17] the same site, I instead see [7:19] my data taken from my connectors. [7:22] And to implement this, you [7:23] just ask Codex. [7:24] Katja, can you show us? [7:26] Katja, sure. [7:28] Okay. [7:29] So let me send this prompt [7:31] to our existing thread. [7:33] So it's still publishing. [7:35] Let me say, [7:38] okay, deploy this as [7:40] soon as possible first. [7:41] And then [7:42] I'm going to say [7:45] add the linear connector to the site [7:48] with read and write access [7:50] and make sure that each person [7:52] can see their assigned ticket [7:53] alongside the relevant launches. [7:55] And I want you [7:57] to let me change a ticket [8:00] status or description and then [8:01] save it back to linear. [8:04] Okay. Great. [8:05] So while this is running, [8:07] let's take a look at the app [8:08] that Codex has built for us. [8:10] So I'm going to open [8:11] this in full screen. [8:15] And as we can see, Codex has [8:18] built what we asked for. [8:19] So we can see our launches. [8:21] We have the views that we asked for. [8:24] Board, calendar, [8:26] and then we can open this. [8:27] We also have our design [8:29] system that I told it to use. [8:31] So this is amazing. [8:33] This was just built in a few [8:35] minutes while John was talking. [8:37] And now, instead of using a simple [8:39] spreadsheet for our updates, with zero [8:42] effort, we can get an interactive site [8:45] that we can share with the team. [8:47] And this is not [8:48] just a demo, right? [8:50] This is actually what [8:51] we do here at OpenAI. [8:54] You know, we're not actually using [8:55] this spreadsheet because we had [8:57] a lot more that launched today. [8:58] But it's the same idea. [9:00] And we actually did have a lot [9:02] of sites that were used all around [9:03] the company to prepare for today. [9:05] And you can do the same. [9:07] So whether it's for yourself, [9:08] your team, or to share an idea [9:11] publicly in just a few minutes [9:13] with zero, you know, [9:16] zero skills or knowledge needed, [9:19] you can just prompt it and have [9:20] a link that you can share. [9:23] So if I want to share [9:24] this with my colleagues, [9:25] as John mentioned, I can [9:28] invite specific people directly. [9:31] So here I'm going to search [9:33] for John and add him. [9:37] Great. And I can also add him as [9:40] an editor, which will allow [9:43] him to edit the app later on. [9:45] So let me save this. [9:47] An editor is a different [9:49] type of permission [9:51] that actually lets [9:54] anyone in your workspace that has editor [9:57] access push updates to the hosted site. [10:00] So we also have a scheduled [10:02] task that was created. [10:04] It is somewhere in here. [10:07] I saw it. Great. [10:08] So we have a scheduled task that is [10:09] linked to our site that will [10:11] update the site daily based on [10:13] updates to the docs on the drive. [10:16] And if you have a scheduled [10:17] task and, you know, a site will [10:19] just suggest it for you now, [10:21] you don't even have to think [10:22] about updating your site. [10:23] It's just doing it on its own. [10:25] So now let's check on our site's [10:27] plugin implementation. [10:30] So it looks like it is [10:32] still running, but it's live. [10:35] Great. [10:36] Great timing. [10:37] So let me open this. [10:41] Nice. [10:42] Okay. [10:43] So I have this. [10:46] It actually already logged me in. [10:49] And so this is my view, right? [10:52] This is what I'm seeing. [10:54] These are my linear tickets. [10:56] And I didn't have to do anything other [10:59] than just adding the linear plugin. [11:01] And so now let's check [11:03] and see what John is seeing. [11:05] John, can you access it? [11:07] All right. [11:09] Can you guys see my screen? [11:11] It looks very similar. [11:13] It is indeed the same site. [11:14] But if I scroll down, [11:16] it instead has my tickets. [11:18] And that data was just fetched [11:20] when I loaded the site and then [11:22] fetched it via my existing [11:24] linear connectors from ChatGPT. [11:29] And there's no need to implement [11:31] third-party integration. [11:33] No need to get API keys. [11:35] No need to reference API docs. [11:37] It comes out of the box with sites. [11:39] It's leveraging each user's [11:40] existing connectors. [11:41] Don't have to think about permissions [11:43] or access. [11:44] And since we have write access [11:46] also here, let's see if I [11:48] can update one of my tickets. [11:51] Okay. It's got to load the ticket. [11:54] All right. Canceled. [11:56] No, it should be in progress. [11:57] Let's try that. [11:59] Save it. [12:04] All right. [12:05] So saved. [12:07] Yay. [12:08] All right. [12:09] Now, let's say I want [12:10] to edit the app. [12:11] I want to edit the app. [12:13] Okay. [12:14] I'm using the in-app browser, and I [12:17] can use a feature called annotations, [12:19] where I can pick out specifically [12:22] which elements I want to change. [12:26] And so that's the button up here. [12:32] Yes. [12:33] And starting today, actually, [12:35] we have a new feature [12:37] for the ChatGPT in-app browser. [12:39] It's annotation extensibility. [12:42] And it's a way for developers [12:43] to prepare custom annotations [12:46] for users of any web app. [12:48] So it's directly embedded [12:49] in the HTML code. [12:51] And custom annotations are [12:54] a way to signal to Codex [12:56] how it can edit the site. [12:57] So for example, you [12:59] can have custom controls. [13:00] You can have suggested prompts. [13:02] So it's easier for site editors [13:03] to discover what they can change. [13:05] And it's especially useful for design [13:08] systems and component libraries. [13:10] Can you show us, John? [13:12] Okay. So let me try clicking [13:14] this Edit UI button. [13:17] All right. You can see here, this is a suggested [13:20] prompt that was built into the site. [13:22] So it made it easier for me [13:24] to know what I can change. [13:27] I can also activate [13:30] annotation mode. [13:32] And let's see, this status bar [13:34] might be kind of hard to see [13:36] for people in the back of the audience. [13:38] Do I have other options here? [13:41] Ah, much bigger. [13:43] And so this was an option [13:44] that was built into the component [13:46] that was rendered onto the page. [13:48] And you can see, as I select [13:50] it, it updates it automatically, [13:52] allowing me to preview it. [13:55] But to actually make this change, [13:58] to commit it, I would then [13:59] tell Codex to do the change. [14:02] And there we go. [14:02] Codex is grinding away on it. [14:05] All right. [14:08] Sent. [14:08] All right. These options were baked [14:11] into the site's HTML. [14:14] If you share a site [14:15] meant to be edited by [14:18] other people, this makes [14:19] contributing much easier. [14:22] Great. So we've seen how we can make [14:25] sites more personal with plugins and how [14:27] we can collaborate on them effectively, [14:29] thanks to custom annotations. [14:31] This is great for internal apps [14:32] that we share within an org. [14:34] But with sites, you can also [14:35] build powerful web apps [14:37] for a general audience. [14:38] Let's see another example where [14:40] the end user is not someone on [14:41] our team, but could be anyone [14:43] out there on the internet. [14:45] Okay. [14:46] So, John, I wanted to do something [14:47] nice for you to commemorate this talk. [14:50] So I'm going to use this app, [14:52] GIF Studio, built with sites, of course. [14:56] So you can switch to my laptop. [15:00] And this site, the idea is that I [15:03] can just create a custom GIF box. [15:06] Okay. [15:07] So the first step is [15:09] to customize the box. [15:11] So let me open the camera here. [15:14] And I'm going to take a picture. [15:17] Great. [15:18] And generate a design. [15:20] So for that, behind the scenes, [15:22] it's using the OpenAI image API [15:24] with our newest image model. [15:26] And we're able to do that because [15:28] with sites, you can add any [15:29] secrets to environment variables. [15:31] So here we added an OpenAI API [15:33] key, but you could integrate [15:35] any third-party service like you [15:36] would on any full-stack web app. [15:40] So my GIF box is ready. [15:42] Now let's go to step two, [15:45] which is finding the items [15:47] to put in the box. [15:49] So I could do this manually by [15:51] clicking through the catalog. [15:53] But frankly, I've kind of gotten used [15:57] to having everything automated for me. [15:59] So I just want to ask [15:59] my agent to do it. [16:00] So that's where WebMCP comes in. [16:04] WebMCP is a new browser standard [16:06] that lets your agent interact [16:08] with the site via exposed tools. [16:10] So any app can expose WebMCP tools. [16:13] And when they're used within [16:15] a WebMCP-enabled browser, [16:17] like ChatGPT's in-app browser, [16:19] users can work with their agents to take [16:21] actions that will update the live app. [16:24] So the difference with something [16:26] like computer use is that the agent [16:28] can use a site via tools instead [16:30] of clicking through the UI. [16:32] So depending on the use case, [16:33] it can be much faster and cheaper. [16:36] For example, here, with computer [16:37] use, the agent will have to kind [16:39] of like click, open each item, [16:41] see the metadata, et cetera. [16:44] Whereas here, with WebMCP, the agent [16:46] can query the backend directly. [16:47] And it's your agent taking action. [16:50] So it has access to your data [16:52] and your apps when it [16:54] calls the WebMCP tools. [16:55] So for example, here, I can say, [16:58] can you look through Slack [17:00] for what John Abrams is into? [17:02] You can search our DMs. [17:04] Then show me some GIF [17:05] recommendations from this catalog [17:07] right here above the box. [17:13] Great. And if we look through Slack, [17:15] we can see that apparently [17:17] John really loves his dog. [17:18] So hopefully my agent picks up on that. [17:22] And in the in-app browser, [17:24] I can see that there are some [17:26] available site tools here. [17:27] So this is what [17:29] my agent is going to use [17:32] to make some suggestions. [17:34] Okay. [17:35] So it's reading Slack. [17:37] And here we go. [17:39] It updated the UI with some suggestions. [17:42] Okay. So that looks great. Oh. [17:45] It looks like it found something, [17:47] some toys for your dog. [17:48] I hope he likes it. [17:51] But the great thing is [17:52] that since this is happening [17:54] in the UI, I can actually collaborate [17:55] with my agent directly from here. [17:58] So let me just remove a few [17:59] things because, you know, I like you, [18:01] John, but I can't expense this. [18:03] So we'll keep it [18:05] under $100 maybe? [18:08] No. That is good. [18:09] Okay. [18:11] So that looks good. [18:12] Let me add to my basket. [18:15] And I will go to the final [18:18] step, which is asking me [18:21] for a personal message. [18:22] So I know it's personal, [18:23] so I should probably write this myself. [18:26] But ChatGPT remembers better [18:28] than me our previous discussions. [18:29] So I'm just going to ask, can [18:32] you create a personalized message [18:34] based on our previous discussions? [18:41] And update the UI with it, please. [18:47] So that's the beauty of UI MCP. [18:48] If you build a site and you want [18:50] it to be personalized to your users, [18:51] you can actually just let [18:53] your users' agents know how they can [18:56] use what they know about the users [18:57] to take action on your app. [19:00] Great. [19:00] So you came up with a nice message. [19:03] I like it. [19:04] So let's confirm. [19:06] And here we go. [19:07] The gift box is ready. [19:08] So John, you should find it [19:09] on your desk very soon. [19:13] Great. So as we evolve towards a world [19:16] where users bring their agents with them [19:19] to navigate the web, you can adapt [19:21] by building your apps in a way [19:23] that works well with agents. [19:24] And the best part is you don't need [19:26] to do any extra work to build this. [19:28] If you use sites, it should [19:30] automatically be added where [19:31] relevant as the site's plugin [19:33] knows how to implement WebMCP. [19:35] With these improvements to the in-app [19:37] browser and sites, we can [19:38] already see what the future [19:40] of the web will look like. [19:41] We're personalized with our own [19:43] agents working on our behalf. [19:46] Katja and I could talk about [19:48] the web and sites for hours, [19:50] but we do need to wrap up. [19:51] Sites allows you to build all [19:53] kinds of experiences. [19:54] You can turn your presentations, ideas, [19:56] and experiments into websites [19:57] and keep them updated automatically, [19:59] but they're much more capable than that. [20:02] They can be full-stack web [20:04] apps that scale automatically. [20:06] They come with auth and a database. [20:08] They now have access [20:11] to your teammates' data via plugins. [20:14] And they're optimized for both [20:15] people and agents. [20:17] As you build web apps for this new [20:19] agentic era, consider how you [20:20] can rethink those experiences. [20:22] Add custom annotations and WebMCP [20:24] to make it easier for both people [20:26] and agents to contribute [20:27] and interact with your apps. [20:29] We can't wait to see all [20:30] the great experiences you [20:31] build and share with sites. [20:33] Thank you.