Sites and the Next Generation of Web Apps | DevDay 2026
OpenAI's Sites platform has evolved from an internal deployment hack into a company-wide tool for turning prompts into full-stack, personalized, collaborativ
By Sean WeldonSites and the Next Generation of Web Apps: An Analysis of OpenAI's Full-Stack Generation Platform
Abstract
This synthesis examines Sites, OpenAI's platform for converting natural-language prompts into deployed, full-stack web applications via Codex. The analysis traces the platform's evolution from an internal deployment prototype into a company-wide tool, reporting adoption by over 70% of OpenAI employees across approximately 8 million hosted sites. Four infrastructural commitments are identified as central to this trajectory: persistent state via an embedded SQLite database, identity through Sign-in with ChatGPT, visitor-scoped personalization through user-attached plugins, and dual-audience interface design serving both human editors and autonomous agents. The latter is realized through custom annotations, which embed editable affordances into site HTML, and WebMCP, a browser standard exposing callable tools to agents. Findings suggest that generated applications are increasingly treated as continuously maintained artifacts rather than static outputs, with implications for how developers architect software in an environment where users delegate navigation and action to agents.
1. Introduction
The automated generation of web applications from natural-language specifications has progressed beyond code synthesis toward end-to-end deployment, in which a model produces not merely source code but a running, addressable, stateful service. Sites is presented as one instantiation of this shift, distinguished by its origin as an internal tool that preceded formal productization and by its emphasis on both human and agentic consumers of the resulting application.
Several terms recur throughout this analysis and are defined here. Sites denotes a hosting platform for full-stack web applications that scale automatically and ship with built-in authentication and a database. Codex is the coding agent responsible for authoring and subsequently updating these applications from prompts. Plugins bundle connectors and skills, granting Codex and ChatGPT access to third-party systems such as Linear, Slack, and Drive. Scheduled tasks are recurring agent invocations that can be bound directly to a site. WebMCP is a browser standard that exposes a site's functionality as callable tools for agents, in contrast to computer use, where an agent interacts with an application by simulating clicks on rendered output.
The central thesis advanced is that Sites reframes the generated web application as a continuously maintained artifact rather than a one-time output of code generation, and that this reframing necessitates infrastructure - persistent state, identity, delegated data access, and agent-callable interfaces - that conventional scaffolding tools typically omit. Section 2 situates the platform against prior deployment practice. Section 3 analyzes adoption patterns and the platform's core infrastructural commitments. Section 4 extracts implementation-level findings and trade-offs. Sections 5 and 6 discuss broader implications and conclude.
2. Background and Related Work
The platform originated as an internal mechanism for deploying full-stack web applications directly from Codex within OpenAI's own infrastructure, prior to any dedicated product team. Notably, the prototype was adopted organically by non-engineers, who propagated generated applications throughout the organization before formal investment followed. This sequence - organic diffusion preceding productization - is itself evidence regarding which barrier was binding: not code authorship, which generative models had already addressed, but deployment, hosting, and maintenance.
The approach can be contrasted with computer use, wherein an agent operates an application by interpreting rendered visual output and simulating user-interface interactions such as clicks and keystrokes. Computer use requires no cooperation from the target application but incurs the latency and token cost associated with rendering, perception, and interaction simulation. WebMCP occupies the opposite design point: applications cooperate explicitly by exposing structured tools, allowing agents to query backends directly rather than navigate a rendered surface. As stated in the source material: "The difference with something computer use is that the agent can use a site via tools instead of clicking through the UI." This distinction frames much of the platform's later design choices around annotation and agent accessibility.
3. Core Analysis
3.1 Adoption Patterns and Emergent Use Cases
Following public launch "a few months ago" relative to the presentation, the platform reportedly hosts 8 million sites, with over 70% of OpenAI employees authoring their own. Observed internal use cases cluster into several categories: brainstorming surfaces, interactive presentations substituting for slide decks, purpose-built interfaces replacing spreadsheets, team-specific internal tools spanning go-to-market, IT, product management, design, and engineering functions, and games. The breadth of this adoption, spanning both technical and non-technical roles, is presented as corroboration of the quoted claim that "at OpenAI, there's now a site for everything."
A representative demonstration converted a team spreadsheet tracking DevDay product launches into a "launch radar" application through a single Codex prompt specifying a shared UI design library, milestone display, filtering by product area, and multiple view modes (list, board, calendar). The full application, including the requested design system, was produced within minutes, illustrating the compression of what would conventionally require a multi-step scaffolding and deployment pipeline into a single generative step.
3.2 State and Automated Maintenance via Plugins and Scheduled Tasks
A structural feature distinguishing Sites from static site generators is the inclusion of a built-in SQLite database per site. This allows Codex-authored scheduled tasks - a feature that launched concurrently with this presentation - to update a site's data directly, without requiring redeployment of the underlying source. Plugins, which bundle connectors (e.g., Linear, Slack) and skills, supply the data Codex writes into this database, enabling sites to remain current with external systems even in the user's absence. The combination of persistent local state, scheduled invocation, and plugin-mediated data access effectively converts a generated application from a snapshot into a maintained service with its own update cadence.
3.3 Identity, Privacy, and Per-Visitor Personalization
Sites incorporate authentication via Sign-in with ChatGPT, with new sites private by default, requiring sign-in verification before access is granted. Sites may optionally be made public, presenting a landing page to anonymous visitors while reserving additional functionality for authenticated users. A notable extension, introduced the day of the presentation, allows teammates signing into a shared private site to attach their own plugins, so that each visitor's view is populated with their personal data from connected services - for instance, their own assigned Linear tickets rather than a shared or generic dataset. A demonstrated Linear integration with read/write access permitted team members to view and edit their assigned tickets directly within the site, with edits synchronizing back to Linear. This visitor-scoped data access is summarized in the source material: "With plugins and Sites, your site can directly access your teammates' data from services Drive, Slack, and Linear." An editor permission tier additionally allows workspace members to push updates to a hosted site without full ownership rights.
3.4 Dual-Audience Interfaces: Custom Annotations and WebMCP
Two mechanisms extend sites to serve both human editors and autonomous agents. Custom annotations, embedded directly into a site's HTML, allow developers to define suggested prompts and controls so that human editors - and Codex acting on their behalf - understand which elements are modifiable, with particular utility for design systems and component libraries; users may preview changes live before committing them. WebMCP, by contrast, targets agent consumers directly: it exposes a site's internal tools for direct invocation by agents operating within WebMCP-capable browsers, such as ChatGPT's in-app browser, bypassing the UI-simulation overhead of computer use. A demonstrated "GIF Studio" site used a secret environment variable to call OpenAI's image API for custom design generation, while a WebMCP-exposed agent searched Slack direct messages to recommend personalized items and compose a contextually informed message. Sites are reported to expose WebMCP automatically where relevant, without requiring additional developer effort.
4. Technical Insights
Several implementation-level findings merit attention for practitioners evaluating or building on similar platforms. First, embedding a database (SQLite) at the site level rather than relying on static generation is what enables scheduled, agent-driven updates without redeployment - a prerequisite for treating generated apps as living services. Second, default-private access paired with Sign-in with ChatGPT establishes a security posture in which exposure is opt-in rather than opt-out, reducing the risk surface of casually generated internal tools. Third, the delegation of plugins to individual visitors rather than binding all data access to the site owner introduces a personalization model with meaningful trade-offs: it increases relevance of in-app data per user but also multiplies the number of third-party credentials and permission scopes a single site must broker correctly. Fourth, the contrast between computer use and WebMCP represents a genuine architectural choice rather than a strict improvement: WebMCP requires the target site to cooperate by exposing tools, which is feasible for sites generated through this platform but not for arbitrary third-party web applications, meaning computer use likely retains relevance as a fallback for uncooperative targets. Finally, the use of secret environment variables (e.g., an OpenAI API key for image generation) within sites indicates that generated applications are expected to integrate external paid services directly, which raises credential-management considerations not elaborated upon in the source material.
5. Discussion
The trajectory described - from internal hack, to organic non-engineer adoption, to formal infrastructure investment - suggests that the binding constraint on application proliferation within organizations was never code generation per se but the surrounding operational concerns of hosting, identity, and data integration. This reframes a plausible industry trend: as code generation models mature, competitive differentiation shifts toward the infrastructure wrapped around generation, specifically authentication, storage, and third-party connectivity, rather than generation quality in isolation.
The dual-audience design - serving both human editors via annotations and agents via WebMCP - signals an anticipated shift in how software is consumed, consistent with the source's framing: "As we evolve towards a world where users bring their agents with them to navigate the web, you can adapt by building your apps in a way that works well with agents." This implies a design obligation for developers extending beyond this platform: applications intended for longevity may need to expose structured, agent-callable interfaces independent of their visual UI, analogous to how APIs supplemented UIs in prior software generations.
A notable gap in the presented material concerns governance and failure modes at scale - specifically, how conflicting or malicious plugin permissions are reconciled when multiple visitors bring heterogeneous connectors to a shared site, and how credential leakage risks associated with embedded secrets (e.g., API keys) are mitigated. These operational questions remain open areas for further investigation beyond what the source material addresses.
6. Conclusion
This analysis identifies Sites as an instantiation of a broader shift from one-time code generation toward continuously maintained, agent-and-human-addressable application artifacts. The platform's reported scale (8 million sites, 70%+ internal adoption) and its four infrastructural commitments - persistent state, built-in identity, visitor-scoped plugin access, and dual-audience interfaces via annotations and WebMCP - collectively indicate that deployment and maintenance infrastructure, rather than code synthesis alone, determines the practical reach of generative application tools. Practitioners building similar systems should weigh the trade-offs of default-private access, per-visitor credential delegation, and the choice between cooperative (WebMCP) and non-cooperative (computer use) agent-interaction models when designing for an environment where end users increasingly act through agents rather than direct interaction.
Sources
- Sites and the Next Generation of Web Apps | 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.