MCP Night The Holiday Edition Keynote: MCP Turns One, Joins the Linux Foundation

At MCP Night: The Holiday Special, WorkOS CEO Michael Grinich traced MCP's journey from local file system hack to industry standard—and announced its new home under the Linux Foundation.

This post is part of our MCP Night: The Holiday Special Recap series. Read the full recap post here.

You can watch the full keynote below or on YouTube.

Michael opened MCP Night: The Holiday Special with a reflection on how quickly the protocol has evolved—and a major announcement about where it's heading next.

The Protocol Lineage

For attendees who "wandered in off the street," Grinich started with the basics. MCP—the Model Context Protocol—brings context to large language models and AI applications. Without context, models get things wrong. With it, they can actually be useful.

But Michael placed MCP in a longer lineage of protocols that transformed computing. TCP established foundational communication between nodes. HTTP built on top of it to exchange content. REST gave developers a pattern for structuring APIs. Each layer enabled the next wave of applications.

MCP, Michael argued, is the protocol for the AI age—the universal connector that brings context into LLMs the way HTTP brought content to browsers.

From Local Hack to Remote Standard

The origin story matters. MCP wasn't initially designed for connecting to remote services. It started as a way for Claude to interface with local environments—your Mac, your file system, your local context. Almost like a standard-out interface to your application.

Developers quickly saw the potential. Even that limited local interface was powerful enough to build tools and scripts that extended what models could do. The community started experimenting, and the protocol evolved.

Remote MCP servers came later, transforming the protocol from a local convenience into a networked standard. Now you can connect to Linear, GitHub, Salesforce, Google Calendar—any service that exposes an MCP server.

One Year of Explosive Growth

MCP turned one year old just weeks before the event—November 25th marked the anniversary. In dog years, Michael joked, that's ancient. But the growth has been anything but slow.

The first MCP Night, held earlier in 2025, expected 250 attendees. 500 showed up. The community has continued accelerating since, with collaboration across Anthropic, OpenAI, Google, Microsoft, and countless startups building on the protocol.

WorkOS's own data reflects the momentum: over 5,400 new MCP servers tracked in recent months, plus growing adoption across clients like Claude, Cursor, VS Code, and Goose.

Security as a First-Class Concern

Michael was direct about the challenges. When you have something new, security is a huge issue. He referenced a recent incident involving a malicious open source package in the MCP ecosystem—identified quickly, but a reminder of the stakes.

The good news: security has become a major focus for the MCP steering committee and open source community. Enterprise security, in particular, is getting attention. The protocol can't succeed in production environments without robust security guarantees.

What's New in the Spec

The bulk of the keynote covered the protocol updates that have landed since the last MCP Night.

Protected Resource Metadata

The biggest authentication change replaces Dynamic Client Registration. The previous approach required services to dynamically register and maintain auth state—complex to implement and incompatible with most existing OAuth systems.

The new approach is simpler: MCP servers expose a URL pointing to a JSON object with OAuth details. Clients fetch that metadata and handle authorization. The result is dramatically easier implementation for server authors while maintaining security.

Long-Running Operations

MCP used to be strictly request-response. You'd make a call, keep your client connected, and wait. For simple queries, that works. For agents running multi-step tasks, it breaks down.

The new async patterns enable non-blocking operations. Kick off a task, close your laptop, come back later—the agent continues working and reports results when finished. This is foundational for multi-agent workflows where operations might take minutes or hours.

Sampling and Elicitation

The protocol now supports bidirectional tool calling. An MCP server can push back into the client with suggestions for what to call next. This enables servers to encode their own planning logic, moving beyond simple request-response into more sophisticated orchestration.

URL Elicitation

This feature solves a real-world workflow problem. An MCP tool can return a clickable link that opens a browser—for authentication flows, third-party authorizations, or any task that requires human interaction.

The user clicks, completes whatever flow is needed in their browser, and the MCP server receives the result. It's secure (the browser handles the sensitive parts) and seamless.

MCP UI Extension

The "wall of text" problem hasn't gone away. AI products still feel terminal-like—we forgot about graphics and rich content experiences.

MCP UI is an extension layer that brings interactive experiences to MCP. Click buttons, sync to canvas, right-click links.

It's not part of the mainline spec, but the extension architecture means teams can experiment without waiting for core protocol changes.

WorkOS Pipes: The Spec in Action

Michael brought Garret Galow on stage to demonstrate these new features working together.

The context: WorkOS had announced Pipes at Enterprise Ready Conference the previous week—a product that connects applications to third-party services like Salesforce, Google Calendar, and Linear without the integration nightmare.

The demo showed Pipes combined with MCP's URL Elicitation feature. Garrett played a project manager asking Claude to help schedule meetings—a task that requires connecting to both Linear (for project context) and Google Calendar (for availability).

When Claude needed access to Linear, it didn't ask Garrett to copy an API key. Instead, the MCP server returned a clickable link. Garrett clicked, authorized in his browser, and the connection was established. Same flow for Google Calendar. No configuration files, no environment variables, no manual token management.

With both services connected, Claude checked Linear for active projects, pulled calendar availability, and scheduled the meeting. The entire interaction was conversational—describe what you need, let the agent coordinate across systems.

The Pipes demo illustrated what becomes possible when MCP's authentication features actually work. Remote servers connecting to authenticated third-party services are where agents become genuinely useful for work. URL Elicitation makes those connections seamless; Pipes handles the token management and API translation behind the scenes.

The Announcement: Agentic AI Foundation

Michael saved the biggest news for the keynote's climax: Anthropic has donated MCP to the Linux Foundation.

But that wasn't all. Block donated Goose, their open source coding agent. Google contributed Agent2Agent (A2A), a protocol for describing how agents communicate. The new organization—the Agentic AI Foundation—launched with 50 companies participating on day one, with WorkOS proud to be a founding silver member.

Public stewardship under the Linux Foundation addresses the adoption concern that's followed MCP since launch: enterprises are wary of depending on infrastructure controlled by a single AI company. Vendor-neutral governance removes that blocker.

MCP Is Just Getting Started

Despite being the third MCP Night of the year, Michael noted that it feels like the beginning. The protocol is entering its first major transition—from single-company project to community-governed standard.

The panel discussion later in the evening would bring together the people steering that transition: David Soria Parra from Anthropic, Jim Zemlin from the Linux Foundation, Nick from OpenAI, and Manik Surtani from Block.

Michael's keynote set the stage: MCP has gone from local file system hack to the connective tissue of the agentic future in just over a year. And with the Linux Foundation providing governance, the next year promises even faster evolution.

Key Takeaways

MCP is the protocol layer for AI, sitting in the same lineage as TCP, HTTP, and REST. Each protocol enabled a new generation of applications; MCP enables the agentic generation.

The spec is maturing fast. Protected Resource Metadata simplifies auth. Async operations enable real agent workflows. Bidirectional communication opens new orchestration patterns.

Security is non-negotiable. Enterprise adoption requires enterprise-grade security.

Vendor-neutral governance changes the game. The Agentic AI Foundation, with backing from Anthropic, OpenAI, Block, Microsoft, and Google, makes MCP safe for enterprise adoption.

Watch the full keynote on YouTube.

Read our full MCP Night: The Holiday Special Recap post here.

‍