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)