Promise Gate

• 

• 

• 

• 

Inspiration

AI agents are becoming increasingly capable of completing tasks, but there is an important difference between doing work and making a promise.

An agent can draft a response in seconds, but accepting a deadline may silently overload the user, delay existing work, or affect other people. Most productivity tools show what is scheduled; they do not stop an agent from creating an unsafe commitment.

I built Promise Gate to explore a simple principle:

An AI agent may analyse and prepare a commitment, but a human should retain authority over the final promise.

What it does

Promise Gate is a capacity-first commitment system powered by WebMCP.

The demonstration begins with a request from Northstar Studio for twelve hours of homepage work by Friday. Promise Gate shows that twenty of the user’s twenty-four safe hours are already promised, leaving only four hours available.

Through WebMCP, an AI agent can:

1. Structure the incoming request.
2. Read the user’s available capacity and existing commitments.
3. Test whether the original promise is feasible.
4. Identify the exact deficit and the commitments that would be threatened.
5. Generate honest alternatives.
6. Stage a feasible option for human review.
7. Finalize only an option that the human explicitly approved.

In the demo, the original request is blocked because it exceeds safe capacity by eight hours. Promise Gate then offers three transparent alternatives:

• Deliver a smaller four-hour risk audit by Friday.
• Move the complete redesign to Tuesday.
• Explicitly displace existing work, requiring separate consent.

Nothing is silently rearranged, and the agent cannot approve its own recommendation.

How I built it

Promise Gate is a responsive React and TypeScript application built with Vite.

The page exposes six WebMCP tools:

• structure_incoming_request
• get_capacity_context
• reserve_original_request
• generate_counteroffers
• stage_counteroffer
• finalize_commitment

The tools operate on a deterministic commitment model containing safe capacity, existing promises, deadlines, staged alternatives, human approval state, and schedule versions.

The workflow separates reversible agent actions from irreversible human decisions. Human approval is deliberately not exposed as a WebMCP tool. The finalization tool rechecks capacity and verifies that the approved option still matches the current schedule version before creating a receipt.

The interface acts as a visible decision ledger. Every tool call changes the page state and adds an entry explaining what happened, so users can understand what the agent did and why.

Challenges

The biggest challenge was making the safety boundary real rather than decorative. It would have been easy to add an “Approve” button while still allowing an agent to bypass it through another tool.

I designed the state model so that finalization fails unless an exact staged option has been approved by a human. It also refuses the original request with a structured OVER_CAPACITY result containing the deficit and threatened commitments.

Another challenge was making agent activity understandable on screen. Promise Gate therefore translates tool results into clear visual states such as Blocked by Gate, Awaiting Decision, and Committed, supported by a visible action ledger.

Finally, I needed the experience to work both as an agent interface and as a normal responsive website without hiding the important decision behind generic dashboard elements.

What I learned

I learned that a useful WebMCP integration is not simply a collection of website buttons exposed as tools. The tool surface can encode authority, reversibility, and policy.

Tool descriptions and schemas also influence how an agent reasons about a workflow. Separating “generate,” “stage,” and “finalize” creates a much safer interaction than exposing one broad “accept request” action.

Most importantly, human-in-the-loop design works best when the human decision is specific. Promise Gate does not ask the user to approve a vague AI plan—it asks them to approve an exact scope, deadline, capacity allocation, and schedule version.

What's next

The current hackathon demonstration uses transparent fictional data so the complete safety model can be evaluated without requiring an account.

The next step would be connecting Promise Gate to real calendars, project-management systems, and communication tools, allowing the same commitment gate to protect real schedules before an agent sends a consequential reply.

Built With

• accessibility
• ai
• apis
• chatgpt
• css3
• design
• html5
• human-in-the-loop
• javascript
• react
• responsive
• sites
• typescript
• vite
• vitest
• web
• webmcp