Max Stoiber Joins OpenAI's Plugin Platform: Why AGI Needs MCP

"AGI is nothing without its plugins." That was Max Stoiber's one-line framing when he announced, on August 31, 2026, that he is joining OpenAI's Plugin Developer Platform team in San Francisco. Stoiber built styled-components and spent years at the center of frontend tooling discourse — so the post landed less as hype and more as a hiring signal with a thesis: frontier models are only as capable as the connectors, SDKs, and review pipelines that let them act on real systems.

If you already ship MCP servers or bundle Agent Skills into portable packages, this is the same story from the inside — OpenAI is staffing the team that turns "model can call tools" into a platform other developers can depend on.

TL;DR — what builders are asking

Why Stoiber's hire signals platform maturity

Stoiber is not a random celebrity attach. His public résumé — styled-components creator, Director of Engineering at Shopify, co-founder of Stellate (GraphQL caching), Senior Staff at Gatsby — is a decade of developer-experience infrastructure: APIs people actually adopt, SDKs that survive semver, and the boring plumbing (auth, caching, schema evolution) that determines whether a platform scales.

That profile maps directly onto what OpenAI's Plugin Developer Platform team owns. Per OpenAI's careers listing for a Software Engineer on that team, the mandate is building APIs, SDKs, and infrastructure for plugins, connectors, MCP integrations, and interactive apps — not training the next foundation model. Stoiber's LinkedIn post on August 31, 2026 framed the thesis bluntly: models are getting smarter, but "OpenAI can't build every connection to every system in the world. The people who know those systems best need to build them."

The subtext for builders: OpenAI is staffing the connective tissue layer as a first-class product surface, not a side project bolted onto ChatGPT. That is consistent with the co-authored Agent Plugins v1.0.0 standard OpenAI shipped with AWS, Cursor, GitHub, VS Code, and Vercel in August 2026 — external packaging standard on one side, internal platform operators on the other.

Why plugins are the bottleneck, not the model

Stoiber's claim is narrower than it sounds on a timeline: he is not saying GPT-class models failed. He is saying capability without attachment looks like AGI in a demo and like a chatbot in production.

The practical stack explainx.ai has been documenting all year maps cleanly:

1. MCP — runtime wire format for tools, resources, and prompts (complete architecture guide).
2. Agent Skills — instructional packages that teach how to use those tools (skills guide).
3. Agent Plugins — portable manifest bundling both for cross-client install (August 2026 standard).

Stoiber joining the Plugin Developer Platform team is OpenAI staffing the layer that makes (3) shippable at scale: SDKs, review queues, connector templates, and the policy surface around what a model is allowed to invoke.

OpenAI's four plugin shapes — and how to pick one

OpenAI's official plugin architecture docs (September 2026) describe plugins as packages people discover, install, share, and publish across ChatGPT and Codex from a shared universal directory. A single plugin can combine:

• Skills — folders with SKILL.md plus scripts, references, templates, or assets that teach repeatable workflows.
• An MCP server — tools with structured input/output schemas, auth requirements, and optional UI resources.
• Lifecycle hooks — commands that run at configured points in the Codex runtime (surface-specific; installing on web does not deploy hook scripts).

The docs recommend starting with the smallest shape that supports your use case and adding MCP or UI later without changing the plugin's purpose:

This table matters because it resolves a common builder mistake: shipping an MCP server when a skill would suffice, or skipping skills when your tools need workflow guardrails. explainx.ai's Agent Skills guide and MCP architecture guide cover each layer in depth; Stoiber's team is the operator that makes both installable from one directory listing.

When UI is warranted, OpenAI points builders at the open MCP Apps UI standard first, adding ChatGPT-specific extensions only when the shared standard lacks a capability. Tools must still work headlessly — the model should complete the workflow without a component, and decide when UI adds value. That aligns with DESIGN.md-driven UI specs for agent-facing surfaces: layout and interaction rules live outside the model weights.

The three-week review queue is a feature, not a footnote

Stoiber mentioned a ~3 week backlog in the plugin review queue. That number matters for two audiences:

• Plugin authors should plan lead time — "submit Friday, live Monday" is not the current operating mode.
• Platform skeptics get evidence the pipeline is real: review exists because connectors are trust boundaries, not marketing badges. The same lesson shows up in MCP security guidance: every server is arbitrary code with network access until scoped.

OpenAI's own MCP docs reinforce why review cannot be instant. Public plugin submission requires a stable, publicly reachable HTTPS endpoint using streamable HTTP transport — local tunnels like ngrok work for developer-mode testing but do not satisfy public submission. Servers that access private data or perform user-scoped actions must implement the MCP authorization flow (OAuth 2.1 with Client ID Metadata Documents where supported). Deep-research and company-knowledge workflows expect read-only search and fetch tools with a compatibility schema; write tools stay behind explicit approval.

That is a lot of surface area for a reviewer to validate: schema correctness, auth boundaries, blast radius of each tool, and whether headless fallbacks exist when UI components fail. A three-week queue is less "OpenAI is slow" and more "connectors are production deployments with security properties, not README demos."

Building MCP servers OpenAI will actually ship

If you are packaging for Stoiber's platform rather than a local loop-engineering harness, OpenAI's build docs specify a concrete checklist:

1. Pick an official SDK — TypeScript (@modelcontextprotocol/sdk) or Python (mcp) for schema helpers and streamable HTTP scaffolding.
2. Define focused tools — one tool per distinct action (list_projects, get_project, update_project) instead of one mega-tool with unrelated modes. Tool descriptions directly affect model selection reliability; see explainx.ai's MCP tool description guide.
3. Return model-readable results without mandatory UI — concise text or structured content the model can reason over; UI is optional enrichment.
4. Deploy to production HTTPS — serverless, container, edge, or traditional app infra; choose based on latency, cold starts, and whether tools need persistent state.
5. Authenticate before you publish — OAuth for user-scoped data; IP allowlists supplement auth but do not replace it.

For ChatGPT developer-mode testing, the flow is: enable Developer mode under Settings → Security, connect your server URL via the Plugins panel, then exercise prompts in chat and deep research. The same MCP server can later be bundled into an Agent Plugin manifest for cross-client install per the August 2026 standard.

From 2023 ChatGPT plugins to MCP-native packages

The first ChatGPT plugin wave (2023) used OpenAPI manifests and a bespoke runtime. The 2026 stack is different in ways that matter for builders:

MCP won the wire-format war because it is client-agnostic — the same server works in Cursor, Codex, Claude Desktop, and custom harnesses, not just ChatGPT. OpenAI co-authoring Agent Plugins with AWS, Cursor, GitHub, and VS Code is the packaging-layer admission that no single vendor will own all agent clients. Stoiber joining the internal platform team is OpenAI betting it can still operate the highest-traffic directory if the connectors are good enough to pass review.

AGI vs MCP servers built by domain experts

The debate Stoiber's post reopened is familiar in agent circles:

The reconcile explainx.ai keeps returning to: models get better at choosing tools; they do not replace the tools. A calendar MCP still encodes OAuth, scopes, and idempotent write semantics. A Figma connector still knows layer IDs. DeepSeek's plugin-first harness and OpenAI's WebMCP challenge both assume externalized capabilities — they disagree on packaging, not on whether the web stays external.

Stoiber's move is a bet that OpenAI will operate that external layer centrally rather than hoping every lab reinvents review, SDK ergonomics, and MCP discovery.

Commentary on Stoiber's LinkedIn thread echoed the same friction explainx.ai documents in production agent posts: integrations die on auth, rate limits, and stale schemas long before model reasoning becomes the bottleneck. Smarter models widen the gap — they can plan elaborate workflows the infrastructure cannot execute. Plugins built by people who own those systems (the Stripe engineer shipping payments MCP, the Figma engineer shipping design MCP) encode idempotency, scope boundaries, and org-specific edge cases that no foundation-model trainer sees in pretraining data.

What domain experts should ship first

Not every connector deserves a public listing on day one. A practical prioritization ladder:

1. Read-only observability tools — search and fetch patterns for deep research; lowest blast radius, fastest review path.
2. Single-write workflows with confirmation — create ticket, draft email, schedule meeting; one tool per action with explicit output schemas.
3. Skills that constrain tool use — teach the model when not to call a destructive tool; pair with Agent Skills before adding MCP complexity.
4. UI components only where inspection beats text — calendars, maps, comparison tables; skip UI for background lookups.

Internal-only MCP servers (private endpoints, org OAuth) can ship before public directory submission. MCP security guidance applies regardless — sandbox network access, scope tokens narrowly, log every tool invocation.

What to do this week if you build agents

1. Package one real workflow as an Agent Plugin — skill instructions + mcp.json — and test in a compatible client from the compatibility matrix.
2. Publish an MCP server for the system your users already live in (Notion, Linear, Postgres, internal APIs). Follow the MCP architecture guide for server patterns and auth boundaries.
3. Document auth and blast radius before submission — review queues exist because bad connectors scale harm faster than bad prompts.
4. Pair skills with specs — UI-facing plugins especially benefit from a DESIGN.md or task spec so the agent does not invent layout from scratch.

Honest limits

• Stoiber's queue depth figure is anecdotal from one insider post — treat ~3 weeks as directional, not SLA.
• Joining OpenAI's platform team does not, by itself, shrink review time; it signals investment.
• "AGI" in the headline is rhetorical. The actionable read is platform maturity for plugins/MCP, not a claim about superintelligence timelines.

Career listing details, queue timing, plugin architecture, and MCP build requirements reflect public posts, OpenAI's careers page, and OpenAI Developers plugin documentation as of September 11, 2026.

Related reading

• What is MCP? Model Context Protocol architecture guide
• Agent Plugins: OpenAI's open standard with AWS, Cursor, GitHub, VS Code
• What are Agent Skills? Complete guide
• MCP security guide for production agents
• DeepSeek Harness v0.1: plugin-first agent stack
• OpenAI WebMCP Challenge: agent-native web
• MCP tool descriptions and selection reliability
• Loop engineering for coding agents