The Future is Ahead of Schedule

MCP Apps and the Acceleration of Just-in-Time Interfaces

In August, Dan Munz and I wrote about the end of civic tech’s interface era, arguing that the rise of AI-generated, just-in-time interfaces would fundamentally change how civic technologists think about designing government services. We acknowledged that these ideas were still mostly theoretical—”this is still an idea that lies in the future,” we wrote. “But the future is getting here very quickly.”

That’s starting to look like a pretty significant understatement.

Just three months later, the organiztions behind the Model Context Protocol (MCP) — the open standard that connects AI assistants to data sources and tools — have announced MCP Apps, a formal extension for delivering interactive user interfaces through the MCP protocol. What we described in our earlier post as an emerging concept is now being standardized by Anthropic, OpenAI, and the MCP community. The timeline from theoretical possibility to a formal specification to guide production implementations wasn’t years or even months. It was weeks.

And we’d better get usef to it – this is what change looks like in the AI era.

From Concept to Standard in Record Time

When we initialy wrote about just-in-time interfaces, we pointed to early experiments and proof-of-concepts: Shopify’s internal prototyping with generative AI, Google’s Stitch and Opal projects, AWS’s explorations with PartyRock. These seemed like interesting signals, but they were scattered efforts using different approaches and solving similar problems in ways that were not obviously compatible.

MCP Apps changes seems poised to change that. It provides a standardized way for AI tools to deliver interactive interfaces — not as a speculative idea, but as a specification that developers can start to implement today. The extension enables AI-powered tools that can present rich, interactive interfaces while maintaining the security, auditability, and consistency that production systems will require.

The design is deliberately lean, starting with HTML-based interfaces delivered through sandboxed iframes. But the implications reach further. As the team beghins this effort notes, this is starting to look like “an agentic app runtime: a foundation for novel interactions between AI models, users, and applications.”

This matters for government digital services because it validates the core thesis of our earlier post: the constraints that forced civic designers to build one interface for everyone is eroding faster than most people anticipated. Certainly faster than we did.

The Infrastructure and the Ingredients

MCP Apps provides the delivery mechanism — a standardized way to serve interactive interfaces through AI systems. The specification itself is deliberately lean, focusing on core infrastructure: HTML templates delivered through sandboxed iframes, JSON-RPC protocols for communication, and multiple layers of security (iframe sandboxing, predeclared templates, auditable messaging, and user consent requirements).

What MCP Apps doesn’t specify is what makes those interfaces good or appropriate for government use. That’s where the foundational work civic technologists have already done becomes critical.

When we wrote about just-in-time interfaces in August, we noted that Shopify’s generative UI prototyping works in part because their design system is built on tokens—named variables that store key aspects of design systems like colors, spacing, and typography. We noted that “tokens aren’t sufficient to make just-in-time UIs a reality, but they probably are foundational.”

MCP Apps now provides the plumbing. But the quality of AI-generated government interfaces will still depend on having the right ingredients: well-structured design systems, clear interaction principles, and encoded policy logic. The U.S. Web Design System, VA.gov Design System, National Cancer Institute Design System, and other design systems used in government use tokens. That existing infrastructure positions government agencies to potentially benefit from MCP Apps when the time comes to experiment with dynamic interfaces — not because MCP Apps requires tokens, but because tokenized design systems can give AI something coherent to work with when generating interfaces.

The architectural decisions in MCP Apps demonstrate another principle that veteran civic technologists will recognize: building on proven patterns rather than inventing everything from scratch. Using MCP’s existing JSON-RPC protocol means developers can use familiar tools. Prioritizing security from the start means it won’t need to be retrofitted later. These are the kinds of decisions that distinguish serious infrastructure from interesting experiments—and exactly the kinds of decisions that government technology teams need to see before they’ll trust a new approach for delivering citizen-facing services.

What This Means for Civic Designers

The rapid standardization of interactive interfaces in AI systems has immediate implications for how civic designers should think about their work.

First, it underscores that the shift from fixed, multitenant interfaces to adaptive, context-specific experiences isn’t just theoretically possible — it’s actively being built. The expertise that civic designers have developed around creating design systems, documenting interaction patterns, and encoding policy logic won’t becoming obsolete. it will becoming more valuable because it provides the neccesary ingredients that AI systems will use to generate appropriate interfaces.

Second, it underscores the importance of getting the upstream architecture right. As we wrote in August, expertise in civic tech will move upstream — from implementation to architecture, from specific solutions to systemic standards. MCP Apps makes this more concrete. The work of defining interaction principles, building component libraries, and establishing visual identity standards becomes foundational to building great experiences, not nice-to-haves.

Third, it highlights the compressed timeline that government agencies are now facing. In previous waves of technological change, governments had years to observe how the private sector adopted new approaches before deciding whether (and how) to follow suit. The telephone era unfolded over decades. The Internet era compressed change to years. The AI era is compressing change to months. MCP Apps emerged from theoretical concept to production standard in less time than it typically takes a government agency to complete a procurement cycle for new software.

This mismatch between the pace of technological change and the pace of government adoption isn’t new – but the gap is widening at an accelerating rate.

The Infrastructure We Need Now

If just-in-time interfaces are moving from concept to production this quickly, what should government digital services teams be doing now to prepare?

The answer isn’t to rush into production deployments of AI-generated interfaces. The better approach is to strengthen the foundations that make such deployments viable when the time is right.

That means investing in design systems that use tokens and are built with the assumption that they’ll need to support dynamic interface generation. It means continuing the hard work of encoding policy logic in formats that AI systems can understand—efforts like the Digital Benefits Network’s Rules as Code community of practice aren’t just preparing for a possible future, they’re building essential infrastructure for a future that’s arriving ahead of schedule.

It also means rethinking how government agencies approach risk and experimentation. The traditional model of waiting until a technology is fully mature before considering adoption doesn’t work when the maturity cycle has compressed from years to months. Agencies need to develop the capacity to experiment safely and learn quickly—running controlled pilots, establishing clear evaluation criteria, and building the organizational muscle to rapidly deploy what works while quickly abandoning what doesn’t.

Acceleration Requires New Muscles

Perhaps the most important takeaway from the rapid emergence of MCP Apps isn’t about the technology itself. It’s about the pace of change in the AI era and what that means for how government organizations operate.

Three months ago, we described just-in-time interfaces as lying in the future. Today, there’s a formal specification proposal for delivering them. The team behind the MCP protocol has built an early access SDK to demonstrate the patterns, and projects like MCP-UI are already implementing support. The cycle of innovation, standardization, and adoption that once took years now happens in weeks and months — even if we’re still in the early stages of this particular evolution.

This creates genuine challenges for government organizations whose processes and decision-making structures were designed for a different era. But it also creates opportunities. Agencies that have invested in the right foundations — strong design systems, encoded policy logic, clear interaction principles — are positioned to benefit from these rapid advances. Those that haven’t will find themselves further behind with each passing month.

The future we wrote about in August isn’t coming. It’s here, and it arrived faster than even we expected. Government digital services will need to adapt to just-in-time interfaces.

The challenge for those of us working in and with governments is whether these organizations can develop the capacity to adapt at the speed that technological change now demands. Because if three months taught us anything, it’s that the next three months will bring changes we haven’t yet imagined.

#artificialIntelligence #governmentServices #justInTimeInterfaces #modelContextProtocol #userExperience