Build What’s Next on the ChatGPT Platform with Plugins | DevDay 2026
OpenAI is expanding its plugin platform with new discovery mechanisms, interactive "plugin extensions" that let developers build native ChatGPT UI experience
By Sean WeldonNative by Configuration: Plugin Extensions and the Re-Architecture of the ChatGPT Plugin Platform
Abstract
This synthesis examines a set of coordinated changes to the ChatGPT plugin platform announced at DevDay 2026, which collectively reposition third-party tools from externally invoked utilities into surfaces that behave as native application features. Three mechanisms are analyzed: intent-based in-conversation discovery ranked by conversion, active usage, and retention; plugin extensions, which expose developer-controlled interface placements (sidebar, side panel, composer at-mentions, file viewer) built atop existing Model Context Protocol (MCP) primitives; and a reengineered build-and-submission pipeline that derives metadata from plugin.json and applies automated review on upload. Reported figures include 4,000 directory plugins, a near order-of-magnitude increase in submissions since the start of the year, and a 3x increase in weekly installations at Supabase following adoption of Sign In with ChatGPT. The analysis indicates that incremental extension of a single protocol, rather than the introduction of parallel API surfaces, is the organizing design principle, with direct implications for developers building agent-integrated products.
1. Introduction
Conversational agent platforms have historically treated third-party capability as a bolt-on: a function call returns a result, the result is rendered as text, and the conversation continues. This model is adequate for discrete lookups but poorly suited to sustained, stateful work such as design iteration, molecular analysis, or meeting follow-up, where a user benefits from a persistent visual surface that remains synchronized with the conversation. The changes examined here address this gap not by introducing a competing framework but by extending the protocol that already governs agent-tool interaction.
Several terms require definition before proceeding. MCP denotes the protocol governing agent-tool interaction, standardizing how a server exposes callable tools to a client. MCP apps (also called MCP widgets) denote interactive components rendered by the client and served by an MCP server, with established methods for updating model context and sending messages. Plugin extensions denote a configuration layer, added to existing MCP tools, that determines where such components may surface within the host interface - sidebar, side panel, composer, or file viewer. A plugin, in this context, is the packaged unit submitted to the directory: a manifest (plugin.json), an MCP server, optional widgets, onboarding skills, and settings definitions.
The central thesis advanced is that ChatGPT is being developed as a collaborative workspace in which third-party tools feel indistinguishable from first-party features, and that this is achieved by layering declarative configuration onto MCP rather than by building a separate application framework. The analysis proceeds through discovery mechanics, interface extension points, identity and economic integration, developer tooling, and the submission pipeline overhaul, before consolidating technical findings and discussing broader implications.
2. Background and Related Work
The relevant intellectual context is the consolidation of agent-tool interoperability around MCP. The platform's position is stated directly: "MCP... is really becoming the core of how agents interact with the world. And as you see today, we're doubling down on MCP." This framing situates plugin extensions as a continuation of, rather than a departure from, prior MCP apps infrastructure, which already permitted servers to return renderable widgets and to update model context from within those widgets. Plugin extensions are described as "new, but... actually just built on top of MCP and MCP apps," meaning existing widget methods work unchanged across the newly introduced surfaces.
A second contextual factor is observed usage growth: plugin installations and plugin-using conversations have risen sharply over the preceding six months, attributed to increasingly complex, multi-tool agent tasks. The characteristic workflow underlying this growth is described as pulling in context, performing analysis or generation, and then taking action on the resulting asset - a three-stage pattern that motivates the design emphasis on bidirectional context sharing and in-place action rather than one-shot tool invocation.
3. Core Analysis
3.1 Discovery as Intent-Driven Ranking
Discovery has shifted from directory browsing toward in-conversation suggestion based on inferred user intent. A representative example: a user asking about turning a website into a full-stack application is surfaced Supabase and Vercel without searching a directory. Ranking of suggested plugins rests on three measurable signals - conversion (install-to-use rate), active usage (daily or weekly usage), and retention (repeat usage) - rather than static popularity or recency. With 4,000 plugins now listed, this ranking mechanism functions as a necessary filter: intent-matching combined with behavioral signals substitutes for manual curation at a scale no longer navigable by browsing alone.
3.2 Plugin Extensions as Native UI Surfaces
Plugin extensions constitute the platform's primary structural innovation, permitting developers to place interface elements in the sidebar, side panel, composer (via at-mentions), and file viewer. These surfaces are described as built on "the same platform" used internally, a claim substantiated by internal examples spanning health, finance, Codex security, code review, and meetings plugins. Critically, the side panel and the conversation share live bidirectional context - the model is aware of which element a user has selected in the panel, and panel state can be updated from the conversation. Demonstrated applications illustrate the range of this mechanism: a meetings plugin that maintains a persistent background agent producing enriched (non-literal) summaries and spawning action-oriented threads; a life-sciences workbench (Rosalind) rendering a 3D molecular viewer in the side panel with region-level selection passed back to the conversation; and a design tool (Magic Path) building a landing page live in the side panel via voice-triggered plugin calls. Ecosystem examples - Atlassian surfacing Jira/Confluence context in the composer, Canva enabling pitch-deck creation and resizing, and Shopify connecting analytics to checkout - indicate that this extension model generalizes across unrelated product categories rather than serving a narrow use case.
3.3 Identity, Economics, and Developer Tooling
Sign In with ChatGPT reduces installation friction by integrating identity directly into the plugin flow; Supabase's reported 3x increase in weekly installations after adoption is offered as direct evidence of this friction reduction. A related economic mechanism allows eligible users to carry ChatGPT token entitlements into third-party products, funding usage through an existing subscription rather than incurring separate platform charges - a design choice that lowers adoption cost for end users of plugin-integrated services. On the build side, sites can now host MCP servers directly, removing separately managed hosting, deployment, and authentication steps, while the App Plugin Creator plugin guides a build-iterate loop recommended to start from a single described user experience. Notably, the OpenAI Developers plugin itself was rebuilt using these same extension mechanisms, indicating internal dogfooding of the new surfaces rather than an externally-only feature set.
4. Technical Insights
Several implementation details carry direct consequences for developers. Sidebar placement requires only an entry points configuration added to an existing MCP tool; side panel placement requires one additional configuration line, meaning the marginal implementation cost of adopting a new surface is low once a baseline MCP tool exists. File type support requires registering a file entry point declaring supported extensions, allowing any file type to be opened as a plugin-owned interactive viewer. Composer at-mention support requires exposing a read-only MCP tool with a specific schema - a query string in, a list of matching objects out - constraining this surface to search-like interactions by design. Settings integration follows an analogous read/update tool pattern: a read tool returns schema and current values, an update tool persists changes, and ChatGPT renders both natively, removing the need for custom settings UI.
A forward-looking technical commitment is ChatGPT's support for an upcoming MCP event spec enabling server-initiated automations, making it the first major MCP client to do so. This spec requires three components: an events/list method, an events/subscribe method that returns a callback URL and signing secret, and a signed webhook delivered by the server when a matching event occurs. This positions MCP servers as capable of pushing updates rather than only responding to pulls, a meaningful extension of the protocol's original request-response orientation. Separately, the submission pipeline now derives required metadata from plugin.json via Codex rather than a manual form, and runs automated review checks on upload, giving immediate feedback; MCP server updates are reflected automatically without a new plugin version submission, reducing iteration latency for developers maintaining live plugins.
5. Discussion
The unifying design decision across these changes is the refusal to introduce a parallel application framework for richer plugin experiences. Every new surface - sidebar, side panel, composer, file viewer, settings, server-initiated events - is implemented as a configuration or schema addition to MCP tools already in use. This has a direct practical consequence: developers with an existing MCP server face a comparatively small marginal cost to adopt new surfaces, since the underlying widget methods, context-update mechanisms, and tool schemas remain constant. This is a materially different trajectory than platforms that introduce separate SDKs per surface type, and it reduces the long-term maintenance burden for third-party developers.
A gap in the available evidence concerns the scalability of the discovery ranking mechanism as plugin count continues to grow well past 4,000; the three cited signals (conversion, active usage, retention) are plausible but their relative weighting and resistance to gaming are not disclosed. Similarly, the near order-of-magnitude growth in submissions, while contextualizing the motivation for the automated review pipeline, raises unaddressed questions about review accuracy and false-negative rates under automation versus prior human review. These are reasonable areas for continued scrutiny as the platform scales.
The broader trend this reflects - host applications ceding interface real estate to third-party code while retaining control over context flow, ranking, and identity - parallels earlier shifts toward protocol-based extensibility in operating systems and browsers, and suggests that agent platforms are converging on a similar layered model: a thin, stable core protocol (MCP) with an accreting set of declarative extension points layered atop it.
6. Conclusion
The central contribution of this round of changes is architectural economy: rather than building a new framework for rich, native-feeling third-party experiences, the platform extends MCP with declarative configuration - entry points, schema-constrained tools, and signed event subscriptions - while reusing existing widget and context-sharing primitives. For developers, the practical takeaway is that an existing, well-formed MCP server is now the primary prerequisite for adopting sidebar, side panel, composer, file viewer, and settings integration, each requiring incremental rather than foundational engineering work. As submission volume and plugin count continue to scale, the durability of this approach will depend on whether declarative extension can keep pace with increasingly complex, multi-surface plugin designs without fragmenting back into surface-specific tooling.
Sources
- Build What’s Next on the ChatGPT Platform with Plugins | DevDay 2026 - Original Creator (YouTube)
- Analysis and summary by Sean Weldon using AI-assisted research tools
About the Author
Sean Weldon is an AI engineer and systems architect specializing in autonomous systems, agentic workflows, and applied machine learning. He builds production AI systems that automate complex business operations.
Sean Weldon builds apps and custom software at 22Atlas.