Meant

A conversational creative editor where agents propose, people decide, and every change stays visible and reversible.

Comment

Inspiration

Creative direction begins as meaning: make the title quieter, give the page more room, or make the story feel more grounded. Conventional design software asks people to translate that intention into layers, coordinates, panels, and property names before they can even judge the result.

An agent can remove some of that translation burden, but only if it understands more than pixels. It needs to know which semantic object is selected, what operations are valid, whether a direction is temporary, which revision is authoritative, and what exact change can be undone.

We built Meant to make that relationship legible. The person directs the work in ordinary language. The agent inspects the composition and proposes a bounded change. The kept artifact changes only through an explicit, visible human decision.

What it does

Meant turns an ordinary-language brief into a structured deck, poster, or infographic that remains visible, selectable, and editable inside the application.

The core loop is:

  1. Say it. Describe the outcome in ordinary language.
  2. See it. Meant renders a visible, inspectable direction.
  3. Shape it. Refine a selected title, frame, or visual object through text, direct controls, or a browser agent.
  4. Keep it. Accept the exact Exploring direction intentionally.
  5. Change your mind. Compare or undo with an inspectable recent revision trail.

Every proposal begins as Exploring, leaving the kept document and durable revision unchanged. Compare names the kept and Exploring versions. Discard removes only the temporary direction. A visible human Keep creates the next durable revision. Undo restores the earlier artifact as a newer revert revision, preserving both events in History.

Text and direct controls provide a complete working path. The code also contains an OpenAI Realtime WebRTC integration that maps voice conversation to the same bounded tools when an entitled session is configured. The submission does not present an unexercised live product-audio round trip as evidence.

Why WebMCP is a strong fit

The most important state in a creative workspace is not visible in a screenshot. It includes the document structure, active selection, allowed operations, design contract, current Exploring draft, authoritative revision, and exact change eligible for recovery.

Meant exposes that state through seven WebMCP tools registered on the page:

  1. get_composition_context reads a compact, revision-aware summary of the active composition.
  2. create_composition_draft starts a deck, poster, or infographic as an Exploring proposal.
  3. preview_composition_turn interprets one ordinary-language direction through the bounded operation registry.
  4. preview_composition_change previews strictly validated semantic operations without committing history.
  5. keep_composition_draft requests that the person confirm the exact draft with the visible Keep control; it never commits by itself.
  6. discard_composition_draft requests visible human confirmation before removing the Exploring draft.
  7. undo_composition_change requests visible human confirmation for an exact, revision-bound revert; it never creates a revision by itself.

That distinction is the point. WebMCP lets an agent collaborate through meaning and explicit authority instead of guessing through screenshots or receiving a private shortcut around the product’s rules.

What people and agents can do together now

Before WebMCP, an external browser agent could see approximate interface pixels and simulate clicks, but it could not reliably know whether a title was the selected semantic object, whether a preview was still temporary, whether another view had advanced the revision, or which historical change was safe to undo.

With Meant’s WebMCP surface, the agent can inspect the current semantic context, create or refine an Exploring direction, and hand the exact consequential choice back to the person. The person can compare the proposal with the kept artifact, then Keep, Discard, or Undo through visible controls. The result is a single creative loop shared by language, touch, direct controls, and browser agents without collapsing authorship into automation.

How we implemented WebMCP

Meant stores each artifact as a composition document with stable frames, semantic nodes, layout modes, bounded style primitives, and an artifact-specific design contract. Decks, posters, and infographics use the same document model while retaining their own dimensions and visual grammar.

The page registers seven tools with document.modelContext.registerTool. Strict JSON schemas reject unknown fields and constrain text, geometry, style values, operation counts, and output size. Human-authored document content is treated as untrusted data. Inspect and preview receipts are compact enough for current browser guidance, while consequential tools return confirmation requests instead of silently changing durable state.

Every edit is compiled into the same operation registry used by the visible product. Preview operations apply immutably to an Exploring branch. Keep rebinds the proposed operations to the authoritative server document, revalidates them sequentially, and commits the updated project plus History through a D1 compare-and-swap transaction. Stale drafts fail visibly. Undo targets one exact eligible commit and creates a newer revert revision rather than deleting history.

The final browser verification used the native WebMCP capability against the running application and an isolated D1 database. Its seven sections passed 42 assertions and two actual races: the complete Exploring/Compare/Keep/reload/Discard/Undo/History loop, a two-page Keep race, a first-use bootstrap race, long public directions with bounded receipts, typed human Keep, a 390×844 mobile loop, and 768×844 touch-target verification. Complementary unit and contract coverage exercises malformed operations, stale authority, and interrupted-response reconciliation. The approved production build was then deployed to meant.protoperfect.io and verified over HTTPS with the expected security headers, session behavior, unavailable test-only routes, all seven WebMCP tools registered, correct rendered product state, and a clean browser console.

Challenges we ran into

The hardest engineering problem was preserving creative flow without weakening state guarantees. Conversation feels fluid; durable work must be exact. We solved that tension with a visible Exploring branch, deterministic operations, explicit human confirmation, revision-bound persistence, and undo-as-history.

The second challenge was making agent authority honest. A tool named Keep can easily imply that an agent has committed work. In the final contract, agent-side Keep, Discard, and Undo are requests for visible human confirmation. Tool receipts report that boundary directly.

The third challenge was concurrency and ambiguous network outcomes. Two views can act on the same draft, or the server can commit while the client loses the response. Meant uses compare-and-swap, conflict states, authoritative History reconciliation, and exact operation identities so it can recover without duplicating a change or claiming success prematurely.

The fourth challenge was showing a coherent creative product rather than a technical proof. We kept the canvas central, preserved the client artifact’s own visual identity, gave desktop and mobile Compare explicit labels, and built the submission film from verified product captures instead of generated interface mockups.

Accomplishments that we’re proud of

  • Seven bounded WebMCP tools registered and exercised through a native browser-agent capability.
  • A real structured artifact that changes inside the application rather than a screenshot-only demo.
  • An explicit Exploring branch with legible Compare, Keep, and Discard states.
  • Agent-side consequence requests that preserve the person’s final authority.
  • Revision-bound D1 persistence with conflict protection and response-loss reconciliation.
  • Undo that creates a newer revert revision and retains the original change in History.
  • Desktop and mobile flows that keep the canvas, current revision, and draft status visible.
  • A final evidence chain built from real product stills, real product clips, and a redacted machine-readable invocation receipt.

What we learned

WebMCP is most useful when a page exposes meaning and authority—not simply more buttons. The important primitive is not “let the agent click Keep.” It is “let the agent understand the exact document, propose a bounded change, and return the consequential decision to the person.”

We also learned that durable history changes the emotional quality of collaboration. People can ask for bolder alternatives when the kept work is visibly safe, temporary directions are clearly labeled, and recovery remains exact.

What’s next

Next we want to deepen the composition system with reusable brand contracts, richer visual primitives, multi-artifact campaigns, collaborative review, export paths, and team-authored templates. Those additions will keep the same contract: the work remains visible, proposals remain reversible, and authorship stays with the person directing it.

What we built during the hackathon

Meant is a new product created during the WebMCP Challenge, informed by lessons from earlier, separate editor and transaction-protocol experiments. The Challenge build is the complete conversational creative product and its agent-native contract: the Meant identity and product experience, structured composition document, seven registered WebMCP tools, reversible Exploring branch, explicit human consequence boundary, durable Keep/Undo History, responsive canvas, output-budget hardening, request security, concurrency recovery, native browser-agent verification, public hosted release, and truthful submission evidence.

Built With

  • webmcp
Share this project:

Updates