Please Make Jarvis So I Don’t Have To – Vision from Kent C. Dodds

Jarvis from Iron Man isn’t just science fiction—it’s becoming a design goal. In this talk, Kent C. Dodds explores what building a “Jarvis-like” experience might look like using MCP, and what challenges still stand in the way.

Problem

Creating a unified AI assistant that knows your context, acts across applications, and proactively helps is a daunting task. The biggest hurdles:

• Trust and privacy in delegating personal tasks.
• Seamless integration without user-managed servers.
• Multimodal communication (text, voice, UI).
• Proactive support and long-term memory.

Today’s tooling—LLMs, UI frameworks, MCP—can enable these features, but they are fragmented.

Intuition

Kent’s framing is simple: imagine an LLM-powered assistant embedded into every part of your digital life, much like a browser today.

“Websites will become MCP servers. The Jarvis client is your host app.”

Instead of building massive monolithic agents, we compose specialized MCP servers (movie booking, calendar, contacts, payment), then expose them to a host agent that coordinates across tools.

Python Code Example – A Jarvis-Like Task Flow

Let’s model a basic version of Kent’s movie-night scenario using async Python, simulating tool calls via MCP-style abstractions:

from typing import List
import asyncio

class MCPServer:
    def __init__(self, name):
        self.name = name

    async def call(self, tool: str, **kwargs):
        print(f"[{self.name}] Calling tool: {tool} with {kwargs}")
        await asyncio.sleep(1)  # simulate processing
        return f"Result from {tool}"

class JarvisClient:
    def __init__(self):
        self.tools = {
            'calendar': MCPServer('Calendar'),
            'movies': MCPServer('MovieFinder'),
            'payments': MCPServer('PaymentGateway'),
            'contacts': MCPServer('Contacts')
        }

    async def plan_movie_night(self, friends: List[str], movie: str, date: str):
        print("Planning movie night...")

        # Step 1: Get nearby theaters
        theaters = await self.tools['movies'].call('find_showtimes', movie=movie, date=date)

        # Step 2: Book tickets
        tickets = await self.tools['movies'].call('book_tickets', friends=friends)

        # Step 3: Create calendar event
        event = await self.tools['calendar'].call('create_event', title=movie, invitees=friends)

        # Step 4: Notify and split payment
        payment = await self.tools['payments'].call('split_payment', amount=120, people=friends)

        print("🎉 All done!")
        return {
            'theaters': theaters,
            'tickets': tickets,
            'event': event,
            'payment': payment
        }

# Simulate
friends_list = ["Josh", "Julie", "Andy"]
movie = "Mission Impossible"
date = "2025-07-31"

asyncio.run(JarvisClient().plan_movie_night(friends_list, movie, date))

This captures the Jarvis experience: no manual tool selection, no JSON config files—just intent and delegation.

Key Notes

• MCP servers become the building blocks for the AI runtime.
• Hosts like a “Jarvis client” coordinate across MCP servers.
• Important Jarvis features: proactive behavior, unified memory, multi-user context, multimodal response.
• Core open issues: async task management, richer tool annotations, UI integration.

Acknowledgements

This guide is based on Kent C. Dodds‘s visionary talk at the Session: Please Make Jarvis So I Don’t Have To, where he imagines an everyday AI assistant powered by MCP.

Special thanks to the Anthropic team and the broader MCP developer community for pushing the boundaries of agent infrastructure.