SignWise

• 

Inspiration

Electronic signing made the final click easy, but it did not make dense agreements easier to understand. Important terms such as automatic renewal, indemnification, liability caps, and data-retention requirements are still easy to overlook.

We wanted to explore a specific question: what if an AI agent could help inside the signing experience itself, while the webpage—not the agent— continued to control consent and signature authority?

That makes agreement review a strong fit for WebMCP. The agent needs more than a detached document API. It benefits from knowing which agreement and clause the person is viewing, the current review state, and whether an exact proposal has received human approval.

## What it does

SignWise is a WebMCP-enabled agreement-review workspace built around a twelve-page fixture contract.

A person can ask an agent to review the agreement in ordinary language. Through tools exposed by the live webpage, the agent can:

• Inspect agreement metadata and its clause index.
• Read individual clauses.
• Add evidence-linked risk findings beside relevant clauses.
• Prepare a concise, editable review.
• Record the exact review revision approved by the person.

Every tool call appears in the page’s activity feed. When the agent flags a clause, the document scrolls to that page and displays the finding beside its evidence.

The agent cannot accept terms, acknowledge clauses, approve its own proposal, or sign the agreement. The final signature control remains available only to the human through the interface.

## How we built it

SignWise uses React, TypeScript, and Vite, with local fixture data so the demonstration remains repeatable.

The React interface and WebMCP tools call the same underlying application service. This avoids creating one behavior for humans and a separate simulated behavior for agents. When a tool changes application state, React updates immediately.

WebMCP registration is isolated behind a small adapter using document.modelContext. The available tool surface changes with the live workflow:

• The agreement view begins with four safe inspection tools.
• Opening the review workspace adds flag_clause and propose_review.
• Human approval exposes record_approved_review for that exact proposal.
• After recording, the temporary capability disappears and the surface returns to four tools.

The review record contains the approved revision, linked finding identifiers, timestamp, and agreement fingerprint. Editing an approved proposal revokes its approval, and recording is protected against duplicate execution.

We tested the application service and WebMCP lifecycle with Vitest. Playwright tests exercise the complete browser workflow, including dynamic tool discovery, visible state changes, approval boundaries, mobile behavior, and operation without WebMCP support. The production application is deployed on Cloudflare.

## Challenges we ran into

The hardest problem was deciding where useful agent action ends and legally meaningful human intent begins.

Making every action require confirmation would weaken the workflow. Allowing the agent to approve or sign would make the experience unsafe. We separated investigation and preparation from consent: the agent may annotate and propose, while only a person may approve an exact revision or continue to signature.

Dynamic tool registration also required careful lifecycle management. A tool being visible is not sufficient authorization, so every state-changing operation validates the current application state again when executed.

Another challenge was keeping the demonstration honest. The agreement analysis comes from the agent reading clauses through WebMCP; it is not a hidden deterministic risk scanner. The fixture contract makes the run reproducible, while the visible activity feed shows the actual tool sequence.

## Accomplishments that we're proud of

We are especially proud that SignWise feels like a coherent human-and-agent product rather than a collection of tool callbacks.

The strongest parts are:

• Evidence appears directly beside the clause that supports it.
• Agent actions visibly update the live interface.
• Tool availability reflects page context and human authorization.
• Approval applies to one exact review revision and is revoked by edits.
• The final record is bound to the agreement fingerprint.
• Signing remains an exclusively human action.
• The complete workflow runs through native ChatGPT Site Tools on the deployed application.

The result is a practical example of an agent helping with a consequential workflow without impersonating the person making the decision.

## What we learned

WebMCP is most valuable when the webpage contributes context and authority that a detached API does not naturally possess.

The important innovation is not simply exposing more buttons as tools. It is allowing the live application to offer the right capabilities at the right moment, publish their effects visibly, and withdraw temporary capabilities when their purpose is complete.

We also learned that human approval should be treated as versioned state rather than a conversational assumption. “Approved” is meaningful only when the application can identify exactly what was approved and verify that it has not changed.

Finally, visible agent activity is part of the product experience. It helps people understand what the agent inspected, what it changed, and where the evidence came from.

## What's next for SignWise

The next step is replacing fixture data with real document parsing while preserving the same consent boundaries.

Future versions could add:

• Organization-specific contract policies and playbooks.
• Suggested redlines and alternative language.
• Comparisons between agreement versions.
• Approval routing to legal, procurement, or security teams.
• Version invalidation when an agreement changes.
• Authorized integration with an e-signature sandbox.
• Persistent review records and signer-side identity controls.

The long-term goal is not autonomous signing. It is a better informed signing process where agents investigate and prepare, applications enforce boundaries, and people retain authority over consequential decisions.

Built With

• chatgpt
• cloudflare-workers
• gpt-5.6-terra
• playwright
• react
• typescript
• vite
• vitest
• webmcp