MOTH FORGE: QUAMPUTE

A human-governed creative workbench where WebMCP agents carry evidence, consequence, and continuity—without taking identity, cost, deletion, or publication away from the creator.

Comment

Inspiration

Most AI-assisted creative tools collapse two different kinds of work into one chat box. The person is expected to provide identity, taste, boundaries, and every supporting detail, while the model is allowed to improvise over missing evidence. That is convenient, but it is not dependable collaboration.

MOTH FORGE: QUAMPUTE began with a different relationship: people and agents should remain differentiated. The creator owns premise, identity, consent, locks, and consequential gates. The agent should do the exhausting work of reading, routing, checking, deriving, preserving provenance, and carrying decisions through a visible workflow.

WebMCP made that relationship implementable on the open web. Instead of guessing at a UI, an agent can receive declared tools with explicit inputs, side effects, and boundaries—while the person sees and controls the same workbench.

What it does

QUAMPUTE turns a creative spark into an evidence-routed Review and honest Export package through six visible stages:

  1. Spark — the person supplies the premise and build shape.
  2. Sources — evidence is attached with an authority role such as canon, reference, inspiration, or format-only.
  3. Locks — creator-owned truths and player boundaries are preserved with revision-safe writes.
  4. Quampute — the system frames the evidence, performs the allowed synthesis, and stops before any unapproved paid action.
  5. Review — conclusions remain separated as confirmed, derived, adapted, reserved, or not applicable.
  6. Export — structured JSON and readable Markdown preserve provenance and QA state without falsely claiming compilation, installation, runtime testing, or publication.

The public challenge build includes a deterministic, no-cost museum-registrar example. It contains a synthetic 29-tab, 607-question authority pack so judges can inspect the complete workflow without exposing private creator material or triggering a model charge.

Why WebMCP is essential

The app registers 13 WebMCP tools covering studio inspection, project discovery, visible premise staging, project creation, exact project reopening, text-source attachment, revision-safe creator-lock updates, Review inspection, creator-answer staging, stage navigation, safe demo preparation, and Export-link retrieval.

This is not a second API hidden behind the website. The WebMCP tools coordinate the same visible state the human is reviewing. A staged answer appears in the on-page form before it is saved. Navigation keeps the human and agent on the same stage. Read-only tools expose provenance, blockers, completion state, and human-only gates. Mutating tools disclose their effects, including when restoration can replace saved demo state.

That makes the experience materially better than either UI automation or a chat-only assistant:

  • the agent does not guess from pixels;
  • the person does not surrender authorship;
  • side effects are declared;
  • state is version-pinned;
  • evidence and inference stay distinct;
  • reserved decisions return to the person;
  • Export does not overclaim completion.

How we built it

  • TypeScript application using the Next.js-compatible Vinext runtime
  • WebMCP tool registration bound to the visible workbench
  • OpenAI Sites deployment
  • Cloudflare D1-compatible SQLite persistence with Drizzle migrations
  • R2-compatible source storage and cleanup receipts
  • Optimistic revision checks, claim tokens, renewable leases, quota-safe writes, and durable deletion ledgers
  • A fresh, single-root public release containing only allowlisted application code and a generated synthetic authority pack
  • Independent exact-commit privacy, migration, build, concurrency, save/reopen, semantic-routing, and production QA

Challenges

The hardest problem was not adding tools. It was making tool behavior honest under failure and concurrency.

We repaired identity migration so a visible creator question survives save and reopen under the same stable ID. We made deterministic demo repair advance revision atomically so it cannot race a paid claim against a stale source snapshot. We made provider cleanup receipts durable even when a terminal result races a human abandonment action. We also refused to label routed evidence as support when the cited source did not actually establish the displayed claim.

The public release introduced a second challenge: proving absence. The release is generated into a fresh directory and fresh one-commit history through a closed allowlist. It contains synthetic tab titles, prompts, identifiers, and examples; it does not contain the private Forge corpus, private character canon, checkpoints, local paths, credentials, or earlier repository history.

Accomplishments

  • Exactly 13 useful WebMCP tools operating on one shared human-agent workbench
  • A deterministic no-cost judge path with no API key and no paid model call
  • 29 synthetic authority tabs and 607 unique, normalization-safe question routes
  • Stable creator-answer save and reopen behavior
  • Honest completion-state and provenance-preserving Export
  • Human-only gates for cost, deletion, uncertain cleanup, and publication
  • One-root public Git history with no hidden prior objects
  • Reproducible frozen offline install, typecheck, lint, migrations, focused regressions, and full production builds
  • Signed-in production QA with zero browser errors and successful Worker outcomes

What we learned

Agent-native design is not about maximizing agent permission. It is about giving the agent the strongest precise capability that preserves the person's role.

WebMCP works best when tools expose meaning, state, and side effects—not just button equivalents. “Inspect the Review candidate and its unresolved creator questions” is more useful than “click the Review tab.” “Stage this answer visibly but do not save it” creates collaboration. A correct tool contract can become part of the product's trust model.

Try it

  1. Open the live URL in ChatGPT's in-app browser.
  2. Ask: “Inspect this Forge and open the completed no-cost example.”
  3. Ask the agent to inspect the Review and explain the difference between confirmed, derived, and reserved results.
  4. Ask it to stage an answer to the one reserved question. The answer appears visibly and remains unsaved until the person chooses the Save control.
  5. Ask for the Export links and inspect the honest completion state.

No API key is configured. The public judge flow makes no paid model call.

Links

What's next

After the challenge, the submitted version will remain frozen during judging. Future work belongs on a separate branch or fork: broader source adapters, additional export destinations, and more domain-specific Forge packs—all while preserving the same human-authority and evidence-custody model.

Built With

Share this project:

Updates

Submission history