RL Nabors built a comic reader that renders interactively inside Claude. Not as a chatbot that describes comics. Not as an app that Claude controls via API. The comic itself - panels, navigation, zoom - lives inside the agent interface, rendered natively using Model Context Protocol (MCP).
The demo is small, but the concept is large: agent UIs don't have to be text boxes. The web platform itself can become the interface.
What MCP Actually Enables
Model Context Protocol is Anthropic's framework for letting agents interact with external systems. Most MCP implementations so far have been tool-calling: the agent reads a database, sends an email, triggers a workflow. Input-output transactions.
Nabors' comic reader does something different. It uses MCP to render a visual interface directly in the chat window. Claude doesn't just describe the comic or fetch metadata. It serves the comic itself - interactive, zoomable, paginated - as part of the conversation. The user navigates panels by talking to Claude. The interface responds in real-time.
This isn't just clever. It's a fundamental shift in how agent UIs could work. Instead of agents being constrained to text responses with occasional API calls, they become platforms - capable of rendering rich, interactive experiences inside the conversational flow.
Why This Changes Interface Design
Most agent interfaces today are chat-first. You type a request, the agent responds with text or a link. If you need to interact with something visual - a chart, a map, a document - you leave the agent and open it elsewhere. The conversation breaks.
What Nabors demonstrates is continuity. The comic, the conversation, and the interaction all happen in the same space. You can ask Claude to find a specific panel, zoom into the artwork, or jump to a page - and the interface updates inline. No context-switching. No leaving the agent to use a separate app.
That changes what agents can be used for. Not just answering questions or triggering tasks, but becoming the interface itself for complex, visual workflows. Data dashboards. CAD models. Video timelines. Medical imaging viewers. All rendered natively inside the agent, controlled conversationally.
The Technical Reality
Building this isn't trivial. MCP handles the protocol, but someone still has to write the rendering logic, the interaction handlers, the state management. Nabors' implementation uses web technologies - HTML, CSS, JavaScript - embedded via MCP responses. Claude serves the interface; the browser renders it.
That's the key insight: the agent isn't doing the rendering. It's orchestrating it. The same way a backend API serves data to a frontend, Claude serves interface components to the chat window. The web platform does the heavy lifting. The agent just decides what to show and when.
This makes the approach scalable. Any web-based interface can theoretically be embedded in an agent conversation. The question isn't can it be done, but which interfaces benefit from being agent-native versus standalone apps.
What Builders Should Be Thinking About
If agent UIs can be infinite canvases - rich, interactive, visually complex - what does that mean for product design?
First, it means agents can replace entire apps for certain workflows. A calendar app could live entirely inside Claude, rendered contextually based on what you're asking about. A project management tool could display boards, timelines, and task lists inline, updated conversationally.
Second, it means conversation and interface can be simultaneous, not sequential. You don't ask the agent a question, get an answer, then click a link. You ask, and the interface updates in front of you. That's faster and more intuitive.
Third, it opens up agent-native design patterns that don't exist yet. What does a calendar look like when it's conversational? What does a spreadsheet feel like when it responds to natural language and renders inline? These aren't just chat-wrapped apps. They're new interfaces entirely.
The Bigger Picture
Nabors' comic reader is a proof-of-concept. But the concept is clear: the next generation of agent UIs won't be constrained to text. They'll be visual, interactive, and platform-native. The agent becomes the operating system. The web becomes the interface.
That's not a distant future. The tools exist today. The only question is who builds it first.