OpenAI Opens ChatGPT Interface to Apps via Sidebars, MCP Automations

Build What’s Next on the ChatGPT Platform with Plugins | DevDay 2026 — OpenAI

OpenAI

OpenAI is shifting ChatGPT from a reactive chat box into a persistent agent workspace by letting developers embed custom interfaces into sidebars and trigger background automations using Model Context Protocol webhooks.

AI-assisted summary of Build What’s Next on the ChatGPT Platform with Plugins | DevDay 2026 — original source. Check the original for full context.

Source published:

Key ideas

  • OpenAI introduced plugin extensions that bring custom UI directly into ChatGPT's sidebar, side panel, composer, and dedicated file viewers using the Model Context Protocol (MCP). (5:52)
  • ChatGPT is the first major client to implement the upcoming MCP event specification, enabling servers to trigger proactive background automations via signed webhooks when users are away from their keyboards. (23:23)
  • The plugin directory submission pipeline was completely overhauled, replacing manual web forms with automated validation of plugin.json files and decoupling backend MCP server deployments from directory re-reviews. (24:32)
  • Token Entitlements allow third-party developers to let users tap their existing ChatGPT subscription tokens inside external applications without requiring separate billing setups. (16:14)

Detailed notes

## Background Published on YouTube by OpenAI on November 11, 2026, this DevDay 2026 session covers how developers can integrate tools, knowledge, and custom interfaces into ChatGPT and Codex using plugin extensions. According to the video description, the presentation demonstrates through live walkthroughs how to transform ideas into functional experiences, distribute them across the platform, and reach new users.

## TL;DR OpenAI introduces plugin extensions, a major platform evolution that allows third-party developers to bring native UI surfaces—such as persistent sidebar tabs, interactive side panels, composer mentions, and file viewers—directly into ChatGPT and Codex. The presentation highlights inline contextual discovery driven by retention and active usage signals, unified onboarding via 'Sign in with ChatGPT', and token entitlements that let users power external tools with their existing ChatGPT subscriptions. Built atop the Model Context Protocol (MCP), the platform adds support for the MCP event specification to trigger background automations and overhauls the directory submission process with automated manifest validation and continuous backend deployments.

## Atmosphere & style The session carries the energetic, pragmatic tone of an engineering keynote, balancing high-level ecosystem vision with granular, technical walkthroughs. Presenters Corey and Max Neuber project a collaborative, developer-first rapport, validating past community frustrations around discovery and review bottlenecks before delivering solutions with confident clarity. The live demonstrations—ranging from real-time meeting transcription and interactive 3D molecular biology models to voice-directed generative canvas layout—create an engaging sense of momentum that naturally builds toward an open, collaborative workshop where attendees are invited to immediately test the new primitives.

## Bulletin - [05:52](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=352s) OpenAI introduced plugin extensions that bring custom UI directly into ChatGPT's sidebar, side panel, composer, and dedicated file viewers using the Model Context Protocol (MCP). - [23:23](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=1403s) ChatGPT is the first major client to implement the upcoming MCP event specification, enabling servers to trigger proactive background automations via signed webhooks when users are away from their keyboards. - [24:32](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=1472s) The plugin directory submission pipeline was completely overhauled, replacing manual web forms with automated validation of plugin.json files and decoupling backend MCP server deployments from directory re-reviews. - [16:14](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=974s) Token Entitlements allow third-party developers to let users tap their existing ChatGPT subscription tokens inside external applications without requiring separate billing setups.

## Key takeaways - [00:25](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=25s) The ChatGPT plugin platform update centers on three main pillars: contextual discovery inside chat streams, richer UI experiences via plugin extensions, and streamlined building with Codex. - [02:15](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=135s) Contextual plugin recommendations are evaluated on quantitative engagement signals—conversion, active usage, and retention—rather than arbitrary platform promotion. - [04:08](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=248s) The Model Context Protocol (MCP) has become foundational as agent workflows increasingly require sequential tool calls across external services. - [05:52](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=352s) Plugin extensions provide native UI real estate across web, desktop, and mobile via sidebar tabs, interactive side panels, composer mentions, and custom file viewers. - [05:52](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=352s) Side panel extensions maintain bidirectional state synchronization, enabling model reasoning engines to dynamically react to selections and interactions on the UI canvas. - [09:38](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=578s) Persistent background agents in sidebar extensions can synthesize external contextual data to display actionable follow-ups that spawn pre-loaded chat threads. - [13:00](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=780s) Voice mode integrations allow users to interact conversationally with plugins like Magic Path while viewing real-time, in-place visual updates on a side canvas. - [16:14](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=974s) Sign In with ChatGPT provides a unified identity layer that cuts onboarding drop-off, with Supabase reporting a 3x weekly installation increase. - [19:01](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=1141s) Modern deployment platforms now natively host MCP servers, reducing DevOps overhead for plugin developers. - [20:17](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=1217s) Adding simple entry_points configuration properties to existing MCP tools automatically mounts them to ChatGPT navigation surfaces like the sidebar and side panel. - [22:03](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=1323s) Plugins can implement composer search tools to ground context dynamically via '@' mentions, as well as native settings interfaces defined by schema-driven MCP tools. - [23:23](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=1403s) The MCP event specification introduces events/list, events/subscribe, and signed webhook delivery to power autonomous, event-driven background tasks. - [24:32](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=1472s) Submission friction was reduced by standardizing manifests into plugin.json, running immediate automated checks, and allowing continuous backend deployments without directory resubmission.

## Detailed walkthrough ### [00:25](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=25s) Three Big Updates: Discovery, Experience, and Shipping

Corey from the OpenAI Developer Experience team opens the session by addressing the evolution of plugins. Users rely on ChatGPT to resolve complex problems that necessitate interacting with diverse external platforms—pulling context, performing analysis or asset generation, and executing concrete actions. Corey expresses gratitude to the developer community while acknowledging the pain points they raised: reliability, friction in the submission pipeline, and the struggle to achieve product discovery. Addressing those concerns directly, the updates focus on expanding the platform, highlighting existing community builds, streamlining deployment via sites, and iterating through Codex.

The keynote frames the release around three core pillars: 1. **Discovery**: Surfaces plugins across ChatGPT via an updated directory and contextual suggestions directly inside active chat conversations. Corey highlights the impact: “And what I'm excited about is that someone could find your product while working on the very task you built it to help with.” 2. **Experience**: Plugin extensions allow developers to bring custom UI directly into ChatGPT’s sidebar or into a side panel beside the chat stream. Built on the identical internal platform OpenAI engineers use, these extensions provide a fully native feel. 3. **Building and Shipping**: Streamlines taking an idea from code to directory listing using Codex and simplified site deployment.

[02:15](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=135s) Contextual Discovery and Ranking Signals

Contextual discovery fundamentally changes how users encounter plugins. Instead of browsing a store before starting a task, users asking questions in natural language are presented with relevant plugins inline. For instance, if an entrepreneur tells ChatGPT, *"I'm building a business and I already have a website. What plugins could help me turn it on or turn it into a full stack web app?"*, the model can proactively suggest tools such as Supabase and Vercel. Users can install them on the fly and continue working without breaking their flow.

These contextual recommendations are driven by quantitative engagement signals rather than arbitrary promotion. Corey outlines the three evaluation criteria: - **Conversion**: The percentage of users discovering the plugin who proceed to install and actively use it. - **Active Usage**: The volume of daily active and weekly active users interacting with the plugin. - **Retention**: The rate at which installed users repeatedly return to the plugin over time.

OpenAI uses these three engagement metrics to highlight plugins that deliver sustained utility, giving high-retention tools broader exposure across ChatGPT and Codex.

[04:08](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=248s) Growth of Agent Workflows and MCP Adoption

The plugin ecosystem has scaled to over 4,000 plugins in the directory, a stark contrast to the initial days when Corey personally managed the original GitHub repository. As autonomous agents take on increasingly complex workflows, their reliance on plugins to fetch external context and invoke backend mutations has surged. Installation rates have risen sharply over the past six months, accompanied by sustained growth in multi-turn conversations leveraging tools.

Modern agent tasks frequently require multiple sequential tool calls across disparate services—spanning software development tooling as well as broader creative workflows. This shift has elevated the Model Context Protocol (MCP) to a foundational standard. As Corey observes: “It's really becoming the core of how agents interact with the world.” Consequently, OpenAI is doubling down on MCP support across its agent harness.

```mermaid flowchart TD accTitle: Agent Workflow with Plugins and MCP accDescr: Diagram illustrating how user prompts trigger agent reasoning, multiple tool calls via MCP, and bi-directional UI feedback.

subgraph ChatInterface["ChatGPT Interface"] User["User Prompt"] SidePanel["Side Panel / Canvas UI"] end

subgraph Execution["Agent Harness"] Model["Agent Model"] MCPClient["MCP Protocol Layer"] end

subgraph Tools["External Systems"] PluginA["Dev Tools / Supabase / Vercel"] PluginB["File Viewer / System APIs"] end

User -->|"Task Request"| Model Model -->|"Tool Calls"| MCPClient MCPClient -->|"Read / Write Action"| PluginA MCPClient -->|"Asset Data"| PluginB PluginA -->|"Context / Results"| Model Model -->|"Render State & Context"| SidePanel SidePanel -->|"Element Selection & State Sync"| Model ```

[05:52](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=352s) Plugin Extensions: Custom Sidebar, Side Panel, and File Viewers

Complex agentic workloads require tighter, more interactive feedback loops than raw text output can offer. Building on last year's Apps SDK—which introduced interactive conversational widgets via MCP tools—OpenAI is launching **plugin extensions**. This framework exposes native ChatGPT and Codex real estate across web, mobile, and desktop clients, giving developers granular control over layout, navigation, and interactions.

```mermaid flowchart LR accTitle: Plugin Extension UI Primitives accDescr: Architecture of ChatGPT UI integration points exposed to plugin developers.

subgraph LeftNav["Navigation"] Sidebar["Permanent Sidebar Tab"] end

subgraph Conversation["Main Window"] Composer["Composer (@ Mentions & MCP Sub-tools)"] end

subgraph SidePane["Contextual Workspace"] SidePanel["Side Panel (Live Sync & Selection)"] FileViewer["Interactive File Viewer"] end

Sidebar -.->|"Launches Workspace"| SidePanel Composer -.->|"Direct Action"| SidePanel Composer -.->|"Opens Asset"| FileViewer ```

Plugin extensions introduce four integration primitives: - **Sidebar Presence**: Gives a plugin a dedicated, permanent home within the main navigation bar, mirroring first-party ChatGPT capabilities. - **Interactive Side Panel**: Sits alongside the conversation stream, allowing users to manipulate UI elements while conversing with the model. Crucially, state is bi-directionally synchronized: “Your interface can share what a user is looking at. So, for example, if somebody is selecting an element in the side panel, ChatGPT and the model can know exactly what element they're looking at.” - **Composer Primitives**: Supports targeted actions right within the text input field via `@` mentions, enabling users to drill down into specific MCP tools and supply structured context. - **Interactive File Viewers**: Allows arbitrary file types—whether research documents or generated media assets—to open in interactive viewers embedded directly inside the side panel.

OpenAI used this exact extension framework to build its internal suites for health, finance, Codex security, code review, and meetings.

[09:00](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=540s) Live Demo: The Meetings Plugin Extension

Corey transitions to a live demonstration of the first-party Meetings plugin to illustrate these extension primitives in action. Anchored permanently in the sidebar navigation, the plugin functions as an integrated workspace. Initiating the note-taking capability prompts for audio input permissions and immediately activates a real-time transcription pipeline inside the client. Corey tests the transcription live on stage (*“Hey there, I'm taking some notes. You can document...”*), demonstrating how live audio capture, model processing, and the persistent side-panel interface coalesce into a single unified workflow.

[09:38](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=578s) Meeting Context and Persistent Agents in the Sidebar

Working across multiple business tools often fragments context, requiring people to dig through Slack or search their email just to find out what happened and decide what to do next. Within ChatGPT, extensions solve this by pulling notes and context directly into view so users can kick off follow-up actions immediately. Demonstrating an existing meeting—a "Waypoint activations metrics review"—the speaker highlights how an agent operating persistently in the background can handle both context retrieval and summarization. Rather than producing a literal, flat transcript, the background agent queries auxiliary internal systems to generate an enriched, actionable summary right in the sidebar.

```mermaid flowchart LR accTitle: Background Agent Context Flow accDescr: Shows how raw meeting context and external systems feed into a background agent to generate enriched summaries and action items in ChatGPT. subgraph S1["Meeting & Integrations"] A["Meeting Conversation"] B["External Systems Context"] end subgraph S2["Background Processing"] C["Persistent Agent"] end subgraph S3["ChatGPT Extension UI"] D["Enriched Meeting Summary"] E["Action Items & New Threads"] end A --> C B --> C C --> D D --> E ```

Because extensions support interactive workflows, the sidebar displays recommended follow-up tasks derived from the conversation. Clicking on any recommended item instantly launches a brand-new chat thread with the necessary context pre-loaded, sending the user straight to work. As the speaker explains:

> “It's pulling on that context to build an enriched summary that's directly here in this view that's helpful for me.”

- The background agent synthesizes details across systems instead of doing word-for-word transcriptions. - Extensions allow users to jump straight from sidebar recommendations into dedicated task threads.

[11:03](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=663s) Domain-Specific Tooling: Rosalind Workbench 3D Reviewer

Extensions also cater to specialized technical fields, such as life sciences. The OpenAI life sciences team developed a plugin named Rosalind Workbench, built specifically for researchers navigating protein design, small molecule development, genomics, and pathology. In a live walkthrough of an existing research thread, the speaker demonstrates the molecular structure reviewer, which features a custom 3D model viewer rendered both inline and inside the side panel.

```mermaid flowchart TD accTitle: Bidirectional Context Architecture accDescr: Illustrates the continuous two-way communication between the 3D model viewer and the ChatGPT chat thread. subgraph UI["Sidebar Extension"] V["3D Molecule Viewer UI"] S["Selected Residues / Structure Edits"] end subgraph Core["ChatGPT Thread"] C["Conversation Context"] M["Model Reasoning Engine"] end V -->|"User selections"| S S -->|"Context updates"| C C --> M M -->|"Follow-up instructions"| V ```

The 3D viewer lets researchers inspect full DNA molecules or zero in on isolated regions, adjust structural representations, switch molecular types, and apply discrete selections. Most importantly, the interface communicates bidirectionally with the underlying model: selections made in the canvas are passed straight into the conversational context, and instructions issued in chat update the 3D viewport. Describing this real-time bridge, the speaker notes:

> “And what's interesting is that any form of this context is now viewable by the conversation.”

- Rosalind Workbench serves life sciences workflows ranging from genomics to protein engineering. - Selections made inside the interactive 3D viewer automatically update the model's active working memory.

[13:00](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=780s) Multimodal Design with Magic Path and Voice

Switching gears from biology to generative design, the speaker showcases Magic Path, an AI-powered design platform accessible directly in the ChatGPT sidebar. Demonstrating how voice interaction pairs with plugin extensions, the speaker activates voice mode to draft a landing page for an imaginary vinyl shop called Side A Records, requesting cream tones, warm colors, bold typography, and abstract shapes inspired by primary colors.

The assistant immediately acknowledges the prompt, opens Magic Path, and starts generating the canvas in real time. The Magic Path extension even renders a customized cursor in the workspace to give visual feedback as it lays out components, including oversized typography, vinyl artwork, record showcases, and a store story section. Because ChatGPT voice can call plugins on the fly, users can converse naturally while watching their layout take form, jumping into edit mode to refine specific elements as needed. Reflecting on this dynamic workflow, the speaker emphasizes:

> “So I think the really interesting here is that work, as I mentioned, is becoming a truly interactive experience, both as you talk to your agent, kick off a task in the background, but also need to see it in a very visual way for you to go in, continue to collaborate, and brainstorm on your next iteration.”

- Voice queries can invoke plugins directly to trigger UI rendering and automated design tasks. - Magic Path supplies an interactive canvas directly alongside the chat thread with support for live in-place edits.

[15:23](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=923s) Ecosystem Integrations: Atlassian, Canva, and Shopify

The speaker details several other major third-party extensions demonstrating how production apps are brought into ChatGPT:

- **Atlassian**: Connects Jira and Confluence to the ChatGPT composer. Users can search their team's workspace, attach a specific page or ticket directly to their prompt, and ask questions with full issue context attached. - **Canva**: Translates ideas into pitch decks within ChatGPT. Users can launch the workflow from Canva’s homepage or simply `@` mention Canva in the conversation, previewing decks in the sidebar with quick options to resize layouts or translate slide copy. - **Shopify**: Integrates store analytics directly into merchant workflows. Store owners can parse real-time store metrics, bundle products based on trends, generate promotional imagery, and route the finalized items through to checkout.

[16:14](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=974s) Sign In with ChatGPT and Token Entitlements

While extensions bring external applications into ChatGPT, developers can also invert the relationship by bringing ChatGPT into their own products via "Sign in with ChatGPT." This identity system streamlines user onboarding for both web applications and associated plugins, substantially reducing friction and boosting installation rates.

| Platform / Feature | Mechanism | Primary Benefit | |:--- |:--- |:--- | | **Sign in with ChatGPT** | Unified OAuth / Identity layer across web apps and plugins | Drastic drop in installation drop-off; Supabase reported 3x weekly install growth | | **Token Entitlements** | Lets users tap their existing ChatGPT subscription tokens inside third-party tools | Users run partner tools funded by their ChatGPT plan without separate subscription charges |

The token entitlement capability fundamentally changes software distribution by removing auxiliary AI billing hurdles for end users. The speaker underscores the significance of this platform addition:

> “So this is a game changer for both our ecosystem partners and our users who can tap into your tool without having to be charged additionally from your platform.”

[17:26](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=1046s) Workshop: Inside the OpenAI Developers Plugin

Transitioning into the practical workshop portion, the speaker walks through the architecture of the OpenAI Developers plugin, a reference implementation designed to help attendees build extensions using the platform's native tools. The plugin moves beyond conversational documentation by giving developers an interactive visual dashboard in the sidebar.

Users can explore guides for building applications with the Responses API or creating autonomous workflows with the Agents API. Clicking on any tutorial card immediately spins up a new chat thread pre-populated with starter prompts. As an example of rapid feature delivery, the team released a custom DevDay tab the day before the event. The tab acts as a native conference companion right inside ChatGPT, letting attendees browse featured sessions—such as the opening keynote, the Stack Overflow session, or the plugins talk—curate a custom schedule, and export a shareable schedule page. As the speaker explains:

> “The OpenAI developers plugin is the best place to help building on top of our platform.”

- Pre-configured cards launch targeted threads with contextual system pre-prompts. - Native extension tabs can host full event agendas, custom schedulers, and shareable web views.

[19:01](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=1141s) Hosting MCP Servers and the Plugin Creator

Corey wraps up the demonstration of native-feeling ChatGPT experiences by pointing out that everything shown—down to generating, sharing, and downloading assets—can be built by third-party developers. A frequent pain point when building plugins that require a Model Context Protocol (MCP) server has been dealing with infrastructure overhead, such as hosting, deployment, and authentication. Modern platforms that enable full-stack web application development and deployment have expanded to support hosting MCP servers directly, allowing developers to remain in flow without context-switching between different DevOps dashboards.

OpenAI provides Plugin Creator, a built-in plugin designed to teach developers how to construct plugins while packaging and deploying fully hosted MCP servers automatically. Corey encourages developers to start small by selecting a single high-impact user problem inside ChatGPT, prompting Plugin Creator to produce a first version, and iteratively refining the output.

“So this is a game changer for staying in flow and continuing to be able to build things.” — Corey

- Plugin Creator functions as a built-in authoring assistant that handles packaging and deploying hosted MCP backends. - Modern web application platforms now integrate native hosting for MCP servers, reducing friction around auth and deployments.

---

[20:17](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=1217s) Extension Points: Sidebar, Side Panel, and File Handlers

Max Neuber, engineering lead for the Plugins Developer Platform, takes the stage to explain the underlying architecture enabling these native-feeling interfaces. While plugin extensions are new to ChatGPT, they are fundamentally built directly on top of MCP and MCP Apps. Developers do not need to rewrite their existing MCP widgets or tool integrations; they can expose those same tools in new surface areas across the ChatGPT client by declaring configuration entry points.

```mermaid flowchart TD accTitle: ChatGPT Plugin Extension Entry Points accDescr: Diagram showing how a plugin can integrate into the ChatGPT sidebar, side panel, and file viewer interfaces.

subgraph Config["MCP Tool Configuration"] EP["entry_points declaration"] FP["file_entry_points declaration"] end

subgraph Surfaces["ChatGPT UI Surfaces"] SB["Sidebar Navigation"] SP["Side Panel (Side-by-Side View)"] FV["Interactive File Viewer"] end

EP -->|"open tool widget"| SB EP -->|"side panel option"| SP FP -->|"declared file extensions"| FV ```

Giving a plugin a permanent icon in the ChatGPT sidebar requires adding a minimal entry-point configuration to the MCP tool that launches the widget. Adding a single extra property to that entry-point block instructs ChatGPT to open the widget in a side panel directly alongside the main chat thread. In this split layout, the underlying MCP App widgets continue to function identically, using standard methods like `updateModelContext` and `sendMessage` to exchange data and state with the ongoing conversation. Furthermore, plugins can declare file entry points with supported file extensions, allowing users to click a file attachment and open it directly inside an interactive, dedicated viewer within ChatGPT.

“You've just seen how our teams and some external developers are able to build experiences now that feel like native features of ChatGPT.” — Max Neuber

- Adding an `entry_points` definition to an MCP tool places the plugin directly into the user’s ChatGPT sidebar upon installation. - Side panel configurations render interactive widgets side by side with the active chat prompt. - MCP App communication primitives like `updateModelContext` and `sendMessage` operate unchanged across side panels and file viewers. - File entry points register specific file extensions, letting the plugin serve as the default interactive viewer for matching files.

---

[22:03](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=1323s) Composer Mentions, Onboarding Skills, and Settings UI

Beyond navigation surfaces, extensions integrate deeply into the core interaction loop: writing prompts and managing account preferences. Plugins can now hook into the ChatGPT composer window using `@` mentions. By exposing a read-only MCP tool configured for mention search, developers enable real-time queries as the user types. The tool accepts a search query string and returns structured matching items, which the user can select and attach to their message as grounded context.

Plugins can also manage the post-installation lifecycle by declaring a dedicated onboarding skill inside `plugin.json`. When a user installs the plugin, ChatGPT prompts them to run this skill, which walks them through initial setup, collects required information through conversation, and invokes MCP tools to persist their answers. To support ongoing configuration, plugins can define a pair of schema-driven read and update MCP tools. ChatGPT reads the setting schema to render native settings controls within the ChatGPT settings UI, saving updates back through the update tool without requiring external configuration dashboards.

“That skill can guide them through setup, ask for the information your plugin needs, and use your MCP tools to save their choices.” — Max Neuber

- Composer search tools must be read-only MCP tools adhering to a strict schema taking a query string and returning candidate objects. - Mention search triggers dynamically when a user types `@` inside the message composer. - Onboarding skills are bundled like standard skills and declared directly in `plugin.json`. - Settings are rendered natively by ChatGPT using schemas fetched via read tools, with updates committed through a paired update tool.

---

[23:23](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=1403s) MCP Event Spec: Event-Driven Background Automations

Max announces that ChatGPT is the first major MCP client to implement support for the upcoming MCP event specification. This standard moves plugins beyond purely reactive user prompts into autonomous, event-driven workflows. MCP servers can now proactively notify ChatGPT when external events occur, allowing ChatGPT to execute tasks and multi-step workflows even when the user is away from their keyboard.

```mermaid flowchart LR accTitle: MCP Event Spec Flow accDescr: Sequence diagram style flow showing event listing, subscription, webhook dispatch, and ChatGPT automation.

subgraph Setup["Registration & Subscription"] A["ChatGPT Client"] -->|"events/list"| B["MCP Server"] A -->|"events/subscribe\n(callback URL + signing secret)"| B end

subgraph Execution["Background Trigger"] E["External Trigger"] --> B B -->|"Signed Webhook"| A A -->|"Execute Automation"| F["ChatGPT Action / Task"] end ```

Implementing the specification requires three lightweight components on the server:

1. **`events/list`**: An MCP method returning the list of event topics and types the server can emit. 2. **`events/subscribe`**: An MCP method called when a user configures an automation, passing down an OpenAI callback URL and a cryptographic signing secret. 3. **Signed Webhooks**: When a matching event occurs, the server dispatches an HTTP POST webhook payload signed with the secret to the callback URL, prompting ChatGPT to launch the requested automation.

“Your MCP server can now tell ChatGPT when something happens and start an automation in response.” — Max Neuber

---

[24:32](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=1472s) Streamlined Directory Submissions and Automatic Server Updates

Addressing plugin distribution, Max acknowledges the community's frustration with directory review delays. Plugin submissions increased by nearly an order of magnitude since the beginning of the year, leading to lengthy review queues. In response, OpenAI redesigned the submission pipeline from scratch to eliminate bottlenecks for both developers and internal reviewers.

The traditional web submission form has been entirely eliminated; all metadata, configuration parameters, and skill declarations now reside within `plugin.json`. Because Codex understands this schema, it can inspect a repository and generate the entire manifest automatically. Furthermore, human-only reviews have been replaced with automated validation suites that execute immediately upon upload, providing developers with real-time feedback on errors that need remediation. Finally, MCP server updates have been uncoupled from plugin re-submissions: once a plugin is approved, developers can deploy updates to their underlying MCP server without triggering an additional directory review cycle.

“First, the submission form is gone.” — Max Neuber

“Instead, all the information we need from you now lives in your plugin.json file so that Codex can generate all of it from your code base, and you barely have to lift a finger.” — Max Neuber

- Plugin submissions expanded by nearly an order of magnitude, prompting a complete rewrite of the review system. - Upload-triggered automated checks provide immediate debugging and validation feedback. - Backend code and MCP server logic can now be deployed continuously without submitting new version requests to the plugin directory.

---

[26:10](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=1570s) Hands-On Workshop: Building with Codex and Plugin Creator

Corey returns to transition the session from presentation to an interactive workshop. He encourages attendees to open their laptops, launch Codex, and target a real project repository rather than hypothetical exercises. Developers can prompt Codex to analyze their codebase and use Plugin Creator to generate an initial plugin manifest and server scaffolding, or instruct Codex to attach an existing MCP plugin to the ChatGPT sidebar and side panel using the new extension points.

Corey emphasizes that while automated starter prompts bootstrap the technical structure, developers must thoughtfully consider the end-to-end user experience, thoroughly test their tools, and iterate on edge cases. OpenAI engineers and platform leads circulate through the room to answer questions, debug schemas, and observe attendee projects during the hands-on session.

“If you have an existing plugin or just starting fresh, you can open up Codex and go to one of your repos.” — Corey

“Max and I, alongside a number of different OpenAI employees here, are going to be in the room to help you build.” — Corey

- Starter prompt for greenfield projects: run Codex against a repository, invoking Plugin Creator to build a first-pass plugin. - Starter prompt for existing plugins: prompt Plugin Creator to add ChatGPT sidebar entry points and side-panel support via plugin extensions. - Engineering staff and workshop leads circulate among attendees to provide direct implementation guidance.

## Notable quotes > [00:25](https://www.youtube.com/watch?v=pIW_8VyvCuQ&t=25s) And what I'm excited about is that someone could find your product while working on the very task you built it to help with. — Corey

## Mentioned Corey, Max Neuber, OpenAI, ChatGPT, Codex, Model Context Protocol, Apps SDK, Supabase, Vercel, Meetings plugin, Rosalind Workbench, Magic Path, Side A Records, Atlassian, Jira, Confluence, Canva, Shopify, Sign in with ChatGPT, OpenAI Developers plugin, Plugin Creator, Responses API, Agents API, DevDay, Stack Overflow

## Video description Bring your tools, knowledge, and interfaces into ChatGPT and Codex with plugin extensions. Through live demos, learn how to turn an idea into a useful experience, share it, and reach new users.

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

Reading summary

At DevDay 2026, OpenAI's developer platform team unveiled major upgrades to ChatGPT plugins, transitioning the ecosystem from conversational add-ons to full application extensions powered by the Model Context Protocol (MCP), native UI surfaces, and background automations. Native UI Surfaces and the MCP Foundation (5:52) The plugin extensions framework enables developers to place native interfaces directly inside ChatGPT's permanent sidebar navigation, interactive side panels, and dedicated file viewers across web, desktop, and mobile clients. Built atop the Model Context Protocol (MCP), these surfaces maintain bidirectional state synchronization with the underlying conversational model. When a user selects or manipulates an element in a side panel or custom viewer, ChatGPT automatically incorporates that context into its active working memory. Engineering lead Max Neuber emphasized that developers do not need to rebuild existing MCP tools to leverage these surfaces; instead, they declare minimal entry-point configurations within their tool manifests to expose widgets across ChatGPT's interface. Multimodal and Domain-Specific Workflows (9:00) Demonstrations highlighted how native extensions support varied domain requirements, moving beyond plain text output. A first-party Meetings extension uses background agents to pull context across enterprise systems like Slack and email, generating enriched summaries and launchable follow-up task threads. For specialized technical research, the Rosalind Workbench plugin incorporates an interactive 3D molecule viewer that lets life sciences researchers adjust molecular structures and pass residue selections directly into the chat prompt. In design workflows, integrations like Magic Path combine ChatGPT voice interactions with live canvas generation, allowing users to verbally direct visual layouts while an agent renders typography and assets side by side in the workspace. Event-Driven Automations and Identity Integration (23:23) Expanding plugins beyond reactive user prompts, ChatGPT is adopting the MCP event specification. By implementing events/list and events/subscribe endpoints, external MCP servers can dispatch signed webhooks that trigger automated ChatGPT workflows even when a user is away from their keyboard. Complementing this operational shift, OpenAI introduced 'Sign in with ChatGPT' and token entitlements. This identity and billing mechanism lets users authenticate with their ChatGPT accounts and apply their existing subscription tokens toward partner services, eliminating separate AI subscription charges. According to OpenAI, Supabase achieved a threefold increase in weekly installs after adopting this unified identity layer. Algorithmic Discovery and Streamlined Deployment (2:15) To address past discoverability challenges across its directory of over 4,000 plugins, OpenAI introduced contextual discovery, which suggests relevant tools inline during natural-language conversations. Rather than relying on manual promotion, directory ranking is driven by quantitative metrics: conversion rates, active daily and weekly usage, and long-term user retention. To speed up development, OpenAI also overhauled the submission pipeline. Form-based submissions were replaced with manifest-driven plugin.json files that Codex can generate directly from a codebase, human-only reviews were superseded by automated validation suites, and MCP server backend updates were uncoupled from directory re-reviews, allowing developers to deploy backend fixes continuously. While the platform significantly lowers infrastructure friction and embeds external tools deeper into the ChatGPT interface, speaker Corey emphasized that sustained success ultimately depends on developers thoroughly testing edge cases and refining user experiences across increasingly autonomous, multi-tool agent workflows.

Source quotes

[0:25] Corey: And what I'm excited about is that someone could find your product while working on the very task you built it to help with.

Original transcript

[0:25] Hi, everyone. [0:26] I'm Corey from [0:27] our Developer Experience team. [0:29] And I'm excited to be [0:30] here to show you what's next [0:31] and what's new with plugins. [0:34] People come to ChatGPT [0:35] to solve all types of problems. [0:37] And that often requires [0:38] working with a number of different [0:39] external systems. [0:41] Plugins make that possible. [0:42] And we've seen incredible use [0:44] cases that have reshaped work [0:45] from pulling in context, [0:47] doing some type of work if [0:49] it's analysis or generation, [0:51] and then taking action on that asset. [0:53] So to everyone who's built [0:54] a plugin, thank you. [0:56] You've also told us what needs [0:58] to be better, reliability, [1:00] the submissions process, and helping [1:01] people discover what you built. [1:03] And if you're building a business [1:05] here, you need a way to reach [1:06] the people who can use your product. [1:08] That feedback has shaped what [1:10] we're building and launching today. [1:12] So I'll show you the extended platform [1:14] of what we're opening up for developers [1:15] and some of the plugins that people [1:17] are already building, [1:20] and how you can build [1:21] and deploy one on sites [1:24] and keep iterating in Codex. [1:26] So let's kick off with three [1:27] big updates. [1:29] First is discovery. [1:31] We're launching new ways for people [1:32] to discover your plugins across ChatGPT, [1:35] from the directory to suggestions [1:37] right in the conversation. [1:38] And what I'm excited about is [1:40] that someone could find your product [1:41] while working on the very task [1:42] you built it to help with. [1:44] Second is the experience. [1:46] We're giving you more ways to customize [1:48] ChatGPT with plugin extensions. [1:50] And you can bring your interface [1:52] into the sidebar or a side panel [1:55] right beside the conversation. [1:56] And because this is the same [1:58] platform that our teams build on, [2:00] it can be an incredibly native [2:01] experience inside of ChatGPT. [2:03] And third is building and shipping. [2:05] We're making it easier to go [2:07] from an idea to a plugin [2:08] that your users can use and build with. [2:11] So we'll show you how to build [2:12] with Codex, deploy on sites, [2:13] and get your plugin into directory. [2:15] So let's start with discovery [2:16] and what that looks like for someone [2:17] using ChatGPT. [2:19] When someone asks ChatGPT [2:21] for help, your plugin might [2:22] have the tools that they need. [2:24] ChatGPT can now suggest it [2:26] right in the conversation, [2:27] giving them a way to discover [2:29] your product and start using it. [2:31] For example, someone might ask [2:32] ChatGPT, I'm building a business [2:34] and I already have a website. [2:36] What plugins could help me [2:37] turn it on or turn it into [2:38] a full stack web app? [2:40] ChatGPT can suggest tools [2:41] like Supabase and Vercel. [2:44] That person has something [2:45] they want to build with, and now [2:46] they can discover the tools, [2:47] install it, and keep working. [2:49] These suggestions draw on evidence [2:51] that people are finding a plugin useful, [2:53] they install it, they use it, [2:54] and they keep coming back. [2:56] We want to help make great plugins [2:58] that are already delivering value reach [3:00] more people who could benefit from them. [3:02] So people who can also find [3:04] your plugin can now find it in new [3:07] ways in the directory and across [3:09] the conversations with suggestions [3:11] now in the conversation. [3:13] So we use three signals [3:14] to help shape this. [3:15] Let's take a look at them. [3:16] One is conversion. [3:18] So how often do people [3:19] who find your plugin go on [3:21] to use it after installation? [3:23] And second is active usage. [3:26] How many people use your plugin [3:28] daily and weekly? [3:29] And third, [3:31] retention. [3:32] How many people keep coming back [3:34] to use it again and again and again? [3:36] So remember, these signals are [3:37] what help you have more usage [3:40] and discovery within the Codex. [3:44] For you as developers, that means when [3:46] people keep coming back to your plugin, [3:47] we want to use all of these [3:49] signals to make sure to help people [3:50] get more ways to discover it. [3:52] And we'll keep building new ways [3:54] to connect users with what you built. [3:57] And to everyone who's already [3:58] bringing their tools and expertise [4:00] into ChatGPT, thank you. [4:02] You're expanding what [4:03] people can do here from building [4:05] an application to designing [4:06] a product or exploring their data. [4:08] There are now 4,000 [4:10] plugins in the directory. [4:11] That gives people a growing [4:13] number of tools to work [4:14] with, and we're seeing that show up [4:16] in how they use ChatGPT. [4:24] We've come a long way since [4:25] the early days when I was managing [4:27] the original GitHub repo for plugins. [4:29] We've worked with a lot of developers [4:30] and partners, some of who are [4:32] in the room today, and seen [4:33] the growth not just internally [4:35] but online in the ecosystem. [4:37] So if you've shipped a plugin [4:38] or we traded messages online, [4:39] I'm really glad you're here. [4:40] You might even see your own [4:41] tweet here on the wall. [4:42] Over the past year, agents have [4:44] taken on more involved work, [4:45] and they need to ask information [4:47] and actions that your plugins provide. [4:49] So we've made plugins a priority, first [4:51] in Codex and now across all of ChatGPT. [4:54] We're seeing that demand [4:55] for plugins grow rapidly, so [4:56] let's take a look at some metrics. [4:58] We see here that installations have [5:00] really risen in the last six months. [5:02] In that time, we've expanded plugin [5:04] support and reliability in our agent [5:06] harness and worked with the ecosystem on [5:08] a shared plugin format, agent plugins. [5:10] So beyond installation, we're also [5:12] seeing more conversations using plugins. [5:15] We've seen that growth in large part [5:16] from people using and asking agents [5:18] to take on more involved tasks. [5:20] Agent threads are becoming more [5:21] complex, pulling in more context [5:23] for more systems, and taking action [5:25] across a variety of new use cases, [5:27] both in developer tooling, but also [5:30] in new and creative avenues that you [5:31] may all be aware of today. [5:33] So that requires access to both [5:35] the information in those tools [5:36] and the ability to make changes. [5:38] So a single task like this can [5:40] involve several tool calls, [5:41] and what that means is we've [5:43] seen immense growth in MCP. [5:45] It's really becoming the core of how [5:47] agents interact with the world. [5:49] And as you see today, we're [5:50] doubling down on MCP. [5:52] So what's next for plugins? [5:55] Well, as those tasks become more [5:57] involved, people need to ways [5:58] to inspect results and make changes. [6:00] We believe that work is a collaborative [6:03] process, and we want to enable new [6:04] modalities for how you analyze, [6:06] think, and create things. [6:08] So to start with that, we're giving [6:09] developers more ways to build those [6:11] experiences inside of ChatGPT. [6:13] Once you start running some of these [6:15] agentic workloads with lots of back [6:16] and forth, you really want [6:18] the thing you're working on right where [6:19] you're chatting with your agent. [6:21] If we zoom back last year, [6:23] we launched the Apps SDK, which [6:25] let you bring interactive widgets [6:26] into the conversation in ChatGPT [6:29] from a tool from an MCP. [6:31] As you saw today in the keynote, [6:33] we're announcing plugin extensions, [6:35] which give you more ways to bring [6:37] your product natively into [6:38] ChatGPT across Codex, sorry, [6:41] in ChatGPT and Codex across [6:42] web, mobile, and desktop. [6:45] So let's go over what this looks like. [6:47] You can build features that feel [6:49] part of ChatGPT in the sidebar, [6:51] because this is the exact [6:52] same platform that we use [6:54] to build features internally. [6:55] Within this new interface, you can [6:57] control the layout, the navigation, [6:58] and the interactions. [7:00] So you decide what people can experience [7:02] and how this feels when they're [7:03] interacting with your tool and platform. [7:06] So we're also providing [7:07] access to another part [7:09] of the experience, the side panel. [7:11] This lets them keep the interface [7:13] besides the conversation, [7:14] and they can make changes directly [7:16] as they interact with your side [7:18] panel or with the agent directly [7:20] talking to the model and going back [7:22] and forth between these two things. [7:24] Your interface can share [7:25] what a user is looking at. [7:27] So, for example, if somebody is [7:28] selecting an element in the side panel, [7:31] ChatGPT and the model can know [7:33] exactly what element they're looking at. [7:34] And that level of context and data [7:36] you can continually pass back and forth [7:37] to create a new modality of working [7:39] that's both collaborative, interactive, [7:41] and helpful for you to get work done. [7:45] You can also build on top [7:47] of the new primitives to add specific [7:49] actions inside of the composer. [7:51] So if you haven't been familiar [7:53] with this, you can add explicitly [7:55] to your plugin, but now you [7:57] can drill down even further by [7:58] providing different tools for MCP [8:00] to expose specific things that you [8:02] want to allow the user to target. [8:04] So that's sending a message, [8:05] reaching for context to provide [8:08] information for who you want [8:10] to be able to interact with. [8:12] You can do that directly [8:13] in the composer with at mentions [8:14] and drilling down deeper. [8:19] In addition to the composer, [8:20] we're also launching new ways for you [8:23] to open up in the file viewer. [8:24] So this means that any file can [8:26] now be opened up inside of ChatGPT. [8:28] Your plugin can make this an interactive [8:31] viewer as somebody's working [8:32] in your type of realm. [8:34] So if this is for research, [8:37] if this is for asset generation, [8:39] any type of those files can be [8:40] opened up directly and exposed [8:41] within the side panel. [8:44] So these pieces give you control over [8:45] how your product works across ChatGPT. [8:48] And let's take a look at some [8:49] of the ones we've created ourselves. [8:52] So we've used the same extension [8:54] platform to build experiences [8:55] like health, finance, [8:57] Codex security, code review, [8:58] and meetings. [9:00] I'm going to show you one example [9:01] by going through the meetings [9:02] plugins myself. [9:07] Here we are in the meetings plugin. [9:09] We quickly showed a video [9:10] of this earlier today, [9:12] but let's do a walkthrough. [9:13] You can see here, I'm [9:14] directly in the sidebar. [9:16] You can customize it so your plugin [9:18] can have a home that's directly there [9:20] for the user and it's permanent. [9:22] And one really interesting thing [9:23] about the meetings plugin, before I [9:25] dive into all this, is that you [9:26] can just take notes directly. [9:27] If I open up this feature [9:29] here and take notes, [9:30] it's starting to transcribe. [9:32] I'm going to give it the permissions [9:33] to continue. [9:34] Hey there, I'm taking some notes. [9:36] You can document [9:38] this and summarize it for me. [9:40] And so of course that was a quick [9:42] meeting, but as you can imagine if [9:43] you're working with your colleagues, [9:44] if you are doing any form [9:47] of meeting context, all that needs [9:50] to be pulled back in for you [9:51] to actually take some action on it. [9:52] Traditionally, you may go into Slack [9:54] and figure out where this thing is [9:56] or you have to look for your email. [9:58] It's just available in ChatGPT [9:59] and that note popped up [10:00] and I can drill down into it [10:01] and start kicking off some actions. [10:03] But let's take a look at a meeting [10:04] that I already had in the past. [10:05] So as an example, we have this Waypoint [10:08] activations metrics review. [10:10] And during the conversation, this is [10:13] something that you could build yourself. [10:15] Afterwards, [10:16] we have an agent that's running [10:18] in the background that does both context [10:20] pulling and meeting summarization. [10:22] So if you have a persistent [10:24] agent that wants to pull [10:25] in context from other systems, [10:27] it doesn't just do literal [10:29] translation from our conversation. [10:31] It's pulling on that context to build [10:33] an enriched summary that's directly here [10:35] in this view that's helpful for me. [10:37] And so that's something that you [10:38] could build yourself and then make [10:39] it exposable in a plug-in [10:41] directly in the sidebar. [10:42] The other thing that's really [10:43] interesting about this is [10:45] within an extension, you can [10:47] always kick off a new thread. [10:48] So these are recommended action items [10:51] after our meeting from this example. [10:53] And I can go in, click it, [10:55] start a new thread, and off to work. [10:56] So that's an experience that you [10:57] could deliver in a plug-in that you [10:58] build on extensions. [11:03] Now let's take a look how [11:04] a researcher might use our life sciences [11:06] plug-in called Rosalind Workbench. [11:09] So this is Rosalind Workbench, [11:11] which is a plug-in our life sciences [11:12] team is building for researchers. [11:16] And I am now here in the sidebar [11:19] for Rosalind Workbench. [11:20] There are all different types of things [11:22] that life science researchers may do, [11:23] from protein design, small molecule [11:25] design, and genomics and pathology. [11:28] But the one that I wanted to show [11:29] you specifically is looking at [11:31] the molecular structure reviewer. [11:32] So I'm going to go into an existing [11:34] thread that I started. [11:36] And a big part of life sciences [11:38] research is looking at a lot [11:40] of different data among DNA molecules. [11:42] And then testing a change, [11:44] doing some analysis. [11:45] And a big part of that is [11:46] maybe you're just ingesting data, [11:48] pulling in context, and telling [11:49] your agent to do something. [11:50] But another way to do this is also [11:52] to look at it in an accurate reviewer. [11:54] You can see it's both in the [11:56] conversation or here in the side panel. [11:58] And we built this 3D model viewer [12:01] for you to be able to expect [12:03] not just the whole DNA molecule, [12:05] but click on a very specific [12:07] part of the molecule. [12:09] Now I'm not a biologist or a life [12:10] science researcher, so I can't [12:12] fully explain all the details here. [12:13] But what I can tell you is [12:15] this plug-in extension gives [12:16] me the ability to change [12:18] the structure, change the type, [12:19] make different selections. [12:20] And what's interesting is that any [12:22] form of this context is now [12:24] viewable by the conversation. [12:26] So that context is continually [12:28] passed back and forth. [12:30] If I send a follow-up message, [12:31] my view can understand that. [12:33] Or if I make a selection [12:34] in some type of interaction, [12:35] the model knows that as well. [12:38] So now a researcher can [12:40] inspect these regions and decide [12:41] what to investigate next. [12:45] And between these two examples, we've [12:47] gone from following up from a meeting [12:48] to examining a protein structure. [12:50] But let's take a look at what [12:52] some developers in the ecosystem [12:53] are building with a really [12:54] cool tool called Magic Path. [13:00] Awesome. So here I am in Magic Path. [13:02] Again, this is the sidebar, [13:04] which gives them a full-built home. [13:06] And these are all different types [13:07] of design projects and web [13:09] pages that I've built. [13:11] Magic Path is an AI design [13:13] platform to help you get going [13:14] and build those different assets. [13:15] I've created all different forms here. [13:17] And I'm going to go in and show [13:19] how this looks with voice. [13:20] So I'm going to go into a new chat. [13:22] And I'm going to turn on ViDai. [13:26] Hey there, chat. [13:27] Can you build me a vinyl [13:29] record store landing page? [13:30] And I want you to use really nice [13:32] topography, use some warm colors, [13:35] and also give it some abstract other [13:38] with a lot of primary colors as well. [13:40] Open it up in Magic Path as well. [13:43] Let me take a look. [13:45] I've got a pointed there. [13:49] I'm laying out a side A records concept [13:51] with cream tones, bold type, and record [13:54] inspired primary color shapes. [13:59] And there it goes. [14:00] It's starting to build in the side here. [14:03] This is a canvas where [14:04] ChatGPT is going on. [14:05] One thing really fun that Magic [14:06] Path has implemented is because [14:08] it knows we're in ChatGPT. [14:09] It's customized this cursor, which is [14:11] a very delightful experience for users. [14:12] So as this is going, one thing [14:14] I'd love to call out is voice [14:16] interacts with plugins as well. [14:18] If you missed that... [14:18] I've called together the oversized type, [14:20] abstract vinyl artwork, a record [14:22] selection, and the store story section. [14:26] Thank you. [14:27] It's continually building. [14:28] Is that within voice, it can [14:29] call the plugin directly. [14:30] So you saw that there in the thread [14:32] that it called the Magic Path plugin. [14:34] It's interacting with it. [14:35] And there you go. [14:35] We have a beautiful site [14:37] here for side A. [14:39] And you can continually [14:40] make edits directly. [14:41] You can go into edit mode [14:42] and select any of these elements. [14:44] All set. The side A records landing [14:47] page is open in Magic Path [14:49] and the preview looks good. [14:51] Great. [14:52] Thank you so much. [14:53] Let's give a round of applause. [14:57] So I think the really interesting here [14:59] is that work, as I mentioned, is [15:01] becoming a truly interactive experience, [15:03] both as you talk to your agent, [15:05] kick off a task in the background, [15:06] but also need to see it [15:08] in a very visual way for you [15:10] to go in, continue to collaborate, [15:12] and brainstorm on your next iteration. [15:15] So that's one way [15:16] to build with extensions. [15:17] Here are a few other examples [15:18] developers are working on. [15:23] So take a look at [15:23] this example with Atlassian. [15:25] It brings your team's work into Jira [15:27] and Confluence into ChatGPT. [15:29] You can search from the message box, [15:31] select a page or issue, and ask [15:33] about it with that context attached. [15:36] In another example, we can see [15:37] here that Canva helps turn an idea [15:39] into a pitch deck inside ChatGPT. [15:41] You can start from Canva's homepage [15:43] or mention it in the conversation [15:45] and describe what you want to create. [15:49] And you can open up the sidebar [15:51] and see the results and keep [15:52] the conversation going with options [15:54] to resize it or translate it. [15:58] And lastly, Shopify [16:00] starts with Store Analytics. [16:01] In their plugin, a merchant uses [16:03] those insights to create a product [16:05] bundle with generated images [16:06] and then helps them take them [16:08] all the way through the checkout. [16:09] So in all of these examples, [16:11] we brought your product into ChatGPT. [16:12] But you can also do the reverse [16:14] and bring ChatGPT into your product. [16:19] So as we mentioned in the keynote, [16:21] we're launching SignIn with ChatGPT. [16:23] With the identity integration, [16:25] developers can add SignIn [16:26] with ChatGPT onto both your web app, [16:29] but also for your plugin. [16:30] And this is shown to increase [16:32] usage of plugins dramatically. [16:34] In one example particularly, [16:37] Supabase, who's implemented SignIn [16:38] with ChatGPT, has seen three times [16:40] the installations of their plugin [16:43] on a weekly basis since implementing. [16:45] So it's a really great way [16:46] to make the experience less [16:48] friction-full for users [16:50] to download it with ease. [16:54] And so that same plugin also lets [16:56] eligible users bring their ChatGPT [16:58] token entitlements into your product. [17:01] So this is an extremely exciting [17:02] thing that was announced this morning. [17:04] But just to double click [17:05] on this, this allows users [17:07] to bring their AI usage onto [17:09] your tool and directly funded [17:10] by their ChatGPT subscription. [17:12] So this is a game changer for both [17:14] our ecosystem partners and our users [17:16] who can tap into your tool [17:17] without having to be charged [17:21] additionally from your platform. [17:26] So we've talked about the new ways [17:28] for people can discover your plugin [17:29] and the new capabilities across [17:30] extensions and SignIn with ChatGPT. [17:32] But how do you build one? [17:34] So this is a workshop, [17:35] and let's dive into that. [17:36] I'll show you how I built [17:37] extensions into the OpenAI [17:38] developers plugins specifically. [17:41] So here we are. [17:43] The OpenAI developers plugin [17:44] is the best place to help [17:46] building on top of our platform. [17:48] And now all of you here at [17:49] DevDay have something to take with you [17:51] and start building with it. [17:52] Or use it as a reference. [17:55] So let's go back into ChatGPT. [17:57] And I'm just going to go over some [17:59] of the features that we've added in. [18:01] So this is something myself [18:02] and the team has worked on. [18:03] You may have already used the OpenAI [18:04] developer plugin directly [18:05] in a conversation to talk [18:07] to our skills and understand [18:09] how you can build on our platform. [18:10] But now you can do [18:11] this in a visual way as well. [18:12] We added this really fun animation [18:14] to call out a recent update, which [18:16] is DevDay, which you're all here at. [18:17] But if you just want to go ahead [18:19] and build something, you can learn how [18:20] to build an app with the responses API, [18:22] build an agent with the agents API. [18:24] And again, as I mentioned, [18:25] you can kick off new threads. [18:26] So if I click this, there you go. [18:28] It just opens a new thread [18:29] with a prepomp ready to go. [18:31] As well, we added this DevDay tab. [18:34] So we just sent this out yesterday [18:36] for folks to play with coming [18:37] in preparation for today. [18:40] But it provided a really native [18:41] experience directly in ChatGPT [18:43] for you to build your own schedule. [18:44] So you can see all [18:45] the featured sessions. [18:46] You could add the opening keynote, [18:48] Stack Overflow, and obviously this talk. [18:51] And you can go in, click [18:53] Save, and Share. [18:54] And these are the different [18:55] options that we made. [18:56] That was a fun way to share [18:57] the schedule with other people. [18:59] And then this opened up a page [19:01] that you could share with anybody, [19:02] download the image. [19:03] The point here is this entire [19:05] experience, which feels really [19:06] native in ChatGPT, something that you [19:08] could build as well. [19:11] All right. [19:12] There's one more thing I want to talk [19:13] about here with building plugins. [19:16] Let's go to the next slide. [19:18] When building plugins, [19:20] if you need to build an MCP, [19:22] you have to think about hosting, [19:23] deployment, or authentication. [19:25] Today, with sites which allow [19:27] you to build web pages and launch [19:29] full-stack web pages, web apps can [19:30] also support hosting MCP servers. [19:33] So this is a game changer [19:34] for staying in flow and continuing [19:36] to be able to build things. [19:37] You can just deploy things [19:39] and use App Plugin Creator, which is [19:41] a built-in plugin for anybody to use [19:42] to learn how to build plugins. [19:43] But they can package and deploy [19:45] a fully hosted MCP. [19:50] So that's what extensions give you. [19:54] New ways to make ChatGPT work the way [19:56] you want, whether you're building [19:57] something for yourself or bringing [19:58] your product to different users. [20:01] And to get started, I suggest [20:02] to pick one thing that you can help [20:04] your users experience within ChatGPT. [20:06] Describe it to Plugin Creator, try the [20:08] first version, and just keep iterating. [20:09] Now, let's invite Max Neuber, [20:11] who leads engineering for our Plugins [20:13] Developer Platform. [20:17] Thank you, Corey. [20:20] You've just seen how our teams [20:23] and some external developers are able [20:25] to build experiences now that feel [20:27] like native features of ChatGPT. [20:29] Let's take a look under the hood [20:30] at how that works and what [20:32] new extension points that you [20:33] can use in your own plugins. [20:35] Now, the thing is, plugin extensions [20:38] are new, but they're actually just built [20:39] on top of MCP and MCP apps. [20:41] So you can take the same tools [20:43] and MCP widgets that you already have [20:46] and bring them into more of ChatGPT. [20:49] Let's start with the sidebar. [20:50] You can now give your plugin a home [20:52] in the ChatGPT sidebar so people can [20:54] open it directly whenever they need it. [20:56] All you have to do is add [20:58] the small entry points configuration [20:59] to the MCP tool that opens your widget. [21:01] And that's it. [21:02] Now it shows up in the sidebar [21:04] of the user that installs your plugin. [21:06] And if you want that to open [21:07] right next to the conversation [21:08] in the side panel, you just [21:10] add one more configuration [21:12] to the entry points and it's done. [21:14] Now your users can interact [21:15] with your app directly [21:17] alongside ChatGPT. [21:19] Now, your actual MCP app widgets [21:21] in this case stay exactly the same. [21:24] They use the same MCP app methods like [21:27] update model context and send message [21:29] to share context with the conversation. [21:31] They're just now in more places. [21:34] And like Corey showed, [21:35] there's one more way people can [21:37] open your widget from a file. [21:39] And again, your plugin can [21:41] now just register to be able [21:43] to open particular file types. [21:44] Add a file entry point, declare [21:46] the types you support the extensions, [21:48] and people can open those files [21:50] directly in your interactive [21:51] viewer inside of ChatGPT. [21:53] So your plugin and your widgets can [21:56] now be available from the sidebar [21:58] right beside the conversation. [22:00] And when someone opens a file, [22:01] it knows how to handle. [22:03] Let's talk about how to bring [22:04] your plugin into the composer. [22:07] People can now search your plugin's [22:09] content right directly from [22:10] the ChatGPT composer and attach [22:12] what they find to their message. [22:14] To support this, you expose a read-only [22:17] MCP tool marked for mentioned search. [22:19] Now, it has to follow a specific schema. [22:21] It takes in a query string, [22:22] the search term, and then returns [22:23] a list of matching objects. [22:25] And ChatGPT just calls [22:27] that tool whenever your user [22:29] types at in the composer [22:31] so the user can bring the right [22:33] context into their conversation. [22:35] Now, once someone installs your plugin, [22:38] how do you help them get started? [22:40] Well, plugins can now also provide [22:42] a custom onboarding skill that users [22:44] are prompted to run after installation. [22:46] That skill can guide them through [22:48] setup, ask for the information [22:49] your plugin needs, and use your MCP [22:51] tools to save their choices. [22:53] You just package that skill [22:55] with your plugin just like any other [22:57] skill and reference it in your plugin [22:59] .json as the onboarding skill. [23:01] And when someone wants to change [23:03] those choices later, your plugin [23:05] can now expose settings right [23:07] in the ChatGPT settings screen. [23:09] You provide a read tool that gives [23:11] us the setting schema and current values [23:12] and an update tool that saves changes. [23:15] And ChatGPT uses that schema to render [23:17] the controls in the ChatGPT settings [23:19] so that users have a familiar [23:21] place to configure your plugin. [23:23] That wraps up extensions. [23:25] That's not all we have [23:26] in store for you today, though. [23:28] I'm excited to announce that ChatGPT [23:29] is the first major MCP client [23:31] to ship support for the upcoming [23:33] MCV event spec in ChatGPT. [23:36] Your MCP server can now tell [23:38] ChatGPT when something happens [23:40] and start an automation in response. [23:42] That means users can ask ChatGPT [23:44] to watch for changes in your product [23:46] and have ChatGPT get to work when [23:48] they happen, even if they stepped away. [23:50] And the beautiful thing about the spec [23:52] is it takes just three very simple [23:54] pieces to support this in your server. [23:57] The first is that you have [23:58] to implement the new event slash [24:00] list MCP method, which tells ChatGPT [24:02] which events your server can send. [24:05] When a user sets up an automation, [24:07] ChatGPT then calls the new event [24:09] slash subscribe MCP method. [24:11] That request tells us a callback [24:13] URL and a signing secret, [24:14] and when a matching event happens, [24:16] your server just sends a signed [24:17] webhook to that URL and ChatGPT [24:19] kicks off the automation. [24:21] That's it. [24:22] It's a really simple spec, [24:23] and so I'm really excited to see [24:25] a lot of you adopting it, [24:26] and especially I'm excited to see which [24:28] workflows your users are going [24:29] to automate once you implement it. [24:32] Now, once you've built your plugin, [24:34] the next step is getting [24:35] it into people's hands. [24:37] Let's talk about everybody's [24:38] favorite topic, submissions. [24:41] Now, I've heard from many of you [24:43] that have already submitted plugins [24:44] to our directory how painful it can be [24:47] to submit a plugin to our directory. [24:49] Submissions have been growing [24:50] extremely fast. [24:52] They've increased by almost an order [24:53] of magnitude since the start [24:54] of the year, which I'm sure many [24:56] of you have noticed since queue [24:58] times have gotten quite long. [24:59] So my team and I, we sat down [25:01] and we reimagined the system from [25:02] scratch to make it easier for you [25:04] and easier for our review team. [25:06] First, the submission form is gone. [25:09] No more form. [25:11] Instead, all the information we need [25:12] from you now lives in your plugin [25:14] .json file so that Codex can generate [25:16] all of it from your code base, [25:17] and you barely have to lift a finger. [25:20] Second, before today, all plugin [25:22] reviews were done by humans. [25:24] We've now automated a bunch [25:26] of the review checks, and they begin [25:27] running on upload so that you [25:30] can get specific feedback about [25:32] what needs fixing immediately. [25:35] Thank you. [25:36] Thank you. I'm very excited about this. [25:38] I don't know how many of you submitted [25:39] plugins, but thank you. [25:41] It's been quite painful so far. [25:43] And last but not least, [25:45] we've automated [25:46] updating your MCP server. [25:48] So when you deploy changes to it, [25:49] you no longer have to submit [25:50] a new version of your plugin [25:52] for them to go live. [25:53] So what that all means is you [25:55] now have access to a much less [25:56] painful process that you don't [25:58] need to do again and again [26:00] as your MCP server evolves. [26:02] With that, let me hand [26:03] it back to Corey. [26:10] Thanks, Max. [26:12] Click to one more slide. [26:13] So we've covered how people discover [26:15] plugins, how extensions let them [26:16] work with your product, and how [26:19] you can build and ship one. [26:20] So let's bring that back to a task [26:22] that your users care about. [26:24] The best way to get started is [26:26] just to try this with a project [26:27] you're already working on. [26:29] So if there's a key takeaway [26:30] from today, we talked about a lot [26:31] of different things, is just to go [26:32] build and try one yourself. [26:34] If you have an existing plugin or just [26:36] starting fresh, you can open up Codex [26:38] and go to one of your repos. [26:39] So for a brand new project, [26:41] just say, hey, review my project, [26:43] use App Plugin Creator, and help [26:44] me implement a first pass plugin. [26:46] Or you can use App Plugin Creator [26:48] and add a home for my existing [26:50] plugin in the ChatGPT sidebar using [26:53] plugin extensions and let users [26:54] open it alongside the conversation. [26:57] Now, remember, these [26:58] are just starting prompts. [26:59] You should dive deeply into [27:01] the spec, think about what [27:02] would delight your users, [27:03] test appropriately, and think [27:04] about the full user experience. [27:06] And as we all know, that does [27:07] take an iterative process. [27:09] But these are great ways to get [27:10] started and get you going [27:11] onto plugin extensions. [27:13] So thank you, everybody. [27:14] Let's go ahead and open up [27:16] your laptops and try this prompt. [27:18] Max and I, alongside [27:19] a number of different OpenAI [27:21] employees here, are going to be [27:22] in the room to help you build. [27:24] This is meant to be a workshop, [27:25] and we're here for questions. [27:26] So we'll be walking around [27:27] and hear what you're building. [27:29] Thank you.