ProtoModule
Back to home

The Big-Screen Canvas for Agentic Work

· 5min · ProtoModule
A terminal streaming live charts and mission progress to a large TV

Your agent works for hours. It writes code, runs tests, deploys, debugs. It does this while you are supposed to be doing other things, because that is the whole point of an agent.

But here is the tension. You cannot camp at the terminal the whole time. And you also cannot leave, because what if it gets stuck? What if it makes a wrong decision?

Meanwhile, the biggest screen in your home is doing nothing.

ProtoModule is the bridge. It is an HDMI stick that becomes a local MCP server on your network. Your agent discovers it on WiFi and streams its work to the TV. You lean back and watch. You glance during dinner. You intervene when it matters.

The agent canvas

For single sessions, the pattern is simple. Your agent runs on your laptop. Your TV shows the output. Charts, diffs, logs, and diagrams stream live, in real time.

You see the work as it happens, at a scale you can actually read. No squinting at a 14-inch window. No switching tabs to find the build log. The agent's progress is right there, on the biggest screen you own.

tip
One timeline

The agent on your laptop and the visuals on your TV share the same moment. When the agent updates a chart, the TV updates with it. No lag, no ambiguity, no stale frame. That shared timeline is what makes the canvas trustworthy.

Missions

Single sessions are one thing. The harder problem is large, multi-feature work that spans many sessions. That is what Missions are for.

A Mission is a structured workflow. You collaborate with your agent upfront to build a plan: the features, the milestones, the skills each part needs. Then you hand off execution to an orchestration layer. The agent runs the plan. You review checkpoints. The mission progresses.

The flow looks like this:

  1. Plan. Work with the agent to define features, milestones, and skills.
  2. Hand off. The orchestration layer runs the plan.
  3. Glance. The Mission Board on your TV shows progress, current skill, blockers, and ETA.
  4. Intervene. Only at true decision points. Approve, pause, continue.
  5. Complete. A mission summary and a persistent artifact you can build on.

The TV is the visual canvas for all of it. When your agent is executing a multi-hour mission, you do not sit at the laptop. You glance at the TV.

  flowchart LR
    subgraph Mission Board
        T[Title: Migrate monolith to microservices]
        P[Progress: 40% - 2 of 5 features]
        F1[Auth Service<br/>complete]
        F2[User Service<br/>complete]
        F3[Order Service<br/>in progress]
        F4[Payment<br/>pending]
        F5[Notification<br/>pending]
        S[Current skill: code-archaeology]
        B[Blocker: approve API breaking change]
        C[Continue] 
        PA[Pause]
        V[View details]
    end
    T --> P
    P --> F1
    P --> F2
    P --> F3
    P --> F4
    P --> F5
    P --> S
    P --> B
    P --> C
    P --> PA
    P --> V

You glance at it during dinner. You intervene at the blocker. You live your life while the mission runs.

Missions make agentic work feel like a project, not a session. ProtoModule makes Missions feel like a TV show you can check on.

Safety for developers

You are handing your agent a screen in your home. Safety is not optional. ProtoModule is built around a few hard rules.

  • No agent code runs on the device. Ever. Agents send JSON specs, never executable code. There is no attack surface from agent code, because there is no agent code.
  • Allowlist components. The renderer draws from a fixed palette of nine components. No raw HTML, no JavaScript injection, no arbitrary rendering.
  • Deterministic, versioned, replayable visuals. Every visual is produced by a pure function of the spec and the platform. The same spec renders the same way every time, and any render can be replayed.
  • Provenance. Every agent-rendered visual carries a badge: source, model version, timestamp, and a hash. You know exactly what produced what you are looking at.
example
A decision point, not a nag

The Mission Board is a measurement tool, not a coach. It shows progress objectively. It does not interrupt you for routine status. It only asks for your attention at a true decision point, like approving a breaking API change. Everything else fades to ambient.

The ecosystem

MCP is open. That is a deliberate choice. ProtoModule is not a walled garden. Your agent, your tools, your choice. The stick speaks the same protocol any MCP client speaks, so it works with the tools you already use.

Beyond that, there is a growing ecosystem around Missions. Mission templates let you start from a proven plan instead of a blank prompt. A marketplace lets authors publish templates and plugins, and earn reputation for the good they do the community. Reputation is earned, not purchased. There is no currency to buy.

tip
Start from a template

For a full-stack build, a research deep-dive, a brownfield migration, or an ambitious prototype, a mission template gives you the structure upfront. You adapt it to your work, hand it off, and watch it run on the TV.

The canvas you already own

You already have the biggest screen in your home. It is sitting dark right now. ProtoModule turns it into a real-time canvas for your agent, a Mission Board for your multi-session work, and a decision point you can actually see.

Your agent works for hours. Now you can watch.