Epic AI
    Loading
    All Posts

    Agent-controlled Apps

    Kent C. Dodds
    Kent C. Dodds

    I have been building an appliance energy simulator, and I wanted to share an exciting possibility about the future of user interaction with you.

    The app lets me tune appliance behavior directly: runtime hours, usage patterns, and so on. It is useful, but manually simulating a real day (like a winter day in Northern Utah) can be tedious. You have to touch a lot of controls, make assumptions, and iterate.

    Doing this would be way too much for a user to do manually, and I never would have built this except I knew my audience wasn't human users, but agents.

    So instead of manually adjusting every appliance, I can ask:

    "Could you simulate a winter day in Northern Utah? Make your best guess and update the simulator."

    And the agent does it. It reasons about usage, updates the live app, and gives me a realistic scenario in seconds.

    That interaction is the magic. You don't just say "show me this thing" and exit the chat world to enter the app world. They live in the same space!

    The core idea is simple: Put your app in the agent.

    Once your app is connected to MCP tools, users can delegate meaningful UI actions to an agent. Instead of clicking through dozens of controls, they can describe intent and let the agent drive the simulation.

    That means faster experimentation, better accessibility, and a much more expressive user experience.

    How it works today (and why it is a little painful)

    Right now, my setup looks like this:

    • The app runs within the ChatGPT conversation (in full screen mode).
    • It keeps a WebSocket connection to my Cloudflare worker.
    • That Cloudflare worker also serves my MCP server.
    • ChatGPT talks to that MCP server.
    • The MCP server triggers updates back to the UI.

    It works today. It is real and surprisingly powerful.

    But it is also more plumbing than it should be.

    Why I am excited about WebMCP

    The future is better: the agent should be able to talk directly to the app in its own context.

    That is what WebMCP unlocks.

    Less indirection, fewer moving pieces, and a much cleaner mental model for developers. More importantly, it makes the "agent controls app" pattern easier to ship and easier to trust.

    And this is not just about ChatGPT. Standards matter because they let this work across clients and platforms. When multiple tools can speak the same protocol, your app becomes more portable and your users get more choice.

    You can build this now

    You do not have to wait.

    You can already ship this experience today with some extra setup. If you are building interactive tools, dashboards, or simulators, this pattern is worth trying now.

    I think this is one of the most compelling UX shifts in front of us: interfaces that users can drive directly, and interfaces agents can drive on their behalf.

    That is where this is heading, and I am very excited about it.

    Share

    All right, I just got to show you this. So I have this appliance energy simulator and I can go into each one of these and make adjustments and like yeah what if I'm running this you know nine hours or whatever a day right okay so I can do all kinds of things with these different appliances. But like, it would take a long time for me to simulate, okay, here's what it's rated for, here's how much I would use on a typical winter day. But I don't know if you noticed this, we're running inside of ChatGPT. This is a ChatGPT MCP app.

    That is pretty cool. And what's even cooler is that I have some tools that synchronize with this app. So I can just say, hey, could you simulate a winter day in Northern Utah? What are my energy usages actually going to be like? Go ahead and make your best guess and judgment and update the simulator for that.

    And with that, now, ChatGPT is thinking and it's actually able to make adjustments to the live app right here, which is pretty sweet. So here right now it's at 45, 000 watts, which is a lot. Peak load is at 136, 000 watts. Daily energy is 1100 kilowatt hours. That is not correct.

    That's basically, let's say that everything is being used at its full capacity all at once, all three Tesla wall connectors, all of that test stuff. So here now, it has updated. So now we're at a much more reasonable, but still kind of crazy 540 kilowatt hours. So maybe some of this test data is a little bit too much. But yeah, this is, I think, really awesome because I can control the app using the agent.

    So I put the app in the agent, and I can communicate with the agent and have it go back and forth with the app. That, I think, is pretty phenomenal. And that is something that I'm really excited to see us doing a lot more in the near future. Here, this is one of the things that's going to make this really easy. Because right now, the way that I did this is kind of a bit of a pain.

    So you have the app that's running, and it's got a WebSocket connection to my Cloudflare instance. And then that is also serving my MCP server. And so then ChatGPT talks to that server, and that server triggers an update to the UI. It would be way better if the chat GPT could talk directly to my app that's running right inside of its context. And that is something that's coming to MCP apps in the future, and it's going to be based on WebMCP.

    So that's why I'm super, super duper excited about WebMCP. Very excited about this. This is a basis for agents controlling MCP apps. And so yeah, look forward to that. But you can do this already.

    Today, this works. You just have to do a little bit of extra work and everything, and I just think this is such a phenomenal experience to offer to your users. Put your app in the agent, and it's not just ChatGPT, it's also Cloud and anybody else who implements this standard. That's why having a standard for this is so awesome. So I hope that this was interesting for you.

    We'll see you in the next one.