AI Delegation Boundary

A WebMCP-powered system for defining, challenging, and approving where agent autonomy ends and human authority begins.

Comment

Inspiration

AI agents are increasingly able to make decisions and take action across real workflows. As their autonomy grows, a harder question follows:

Where should agent authority end, and where should human authority begin?

AI Delegation Boundary began as a way for us to understand WebMCP by building with it.

While developing the project, we realized that WebMCP could support more than letting an Agent operate a web page. The web application could hold the current boundary, constraints, human judgments, and approval state, while the Agent reasons and acts through tools exposed by that page.

That led to the core idea:

Make AI delegation itself something a human and an Agent can examine, challenge, revise, and approve together.

What it does

AI Delegation Boundary helps a human decide what an AI Agent may do on its own.

A human first defines the work being considered.

The Agent then uses WebMCP tools exposed by the page to:

  1. Inspect the current delegation boundary.
  2. Propose a revision.
  3. Challenge that revision with a concrete scenario.
  4. Re-test it against Guardrails and previous human decisions.
  5. Inspect the revision history and current state.

When the Agent finds a case that requires judgment, it stops and returns control to the human.

The human decides whether that case should be:

  • Agent-only
  • Human review
  • Not delegated

That judgment becomes a regression test for future revisions.

The collaboration loop is:

Proposal → Challenge → Human Judgment → Re-test → Human Approval → Apply

The Agent cannot approve its own revision. Only the exact revision explicitly approved by the human can be applied.

How we built it

AI Delegation Boundary is built with React, TypeScript, Vite, and WebMCP, and is deployed on GitHub Pages.

The web application holds the delegation boundary, Guardrails, human judgments, revision state, approval, and applied state.

WebMCP exposes five normal tools to the Agent:

  • Inspect the delegation workspace
  • Propose a boundary revision
  • Challenge the current revision
  • Review the current revision
  • Inspect revision history

After the exact current revision receives explicit human approval, an additional apply capability becomes available.

There is no dedicated AI backend. The conversational Agent works directly through the WebMCP tools exposed by the page.

Our architectural principle is:

Conversation is the Agent; state and authority live in the web app.

Review combines three different controls:

  • Guardrails — deterministic invariants that must not be violated
  • Known Decisions — previous human judgments preserved as regression tests
  • Agent Challenges — concrete scenarios generated to actively challenge the current boundary

Challenges we ran into

The hardest part was not exposing tools to an Agent. It was designing the authority model around them.

We needed to ensure that the Agent could propose and challenge changes without granting itself additional authority.

We also had to make sure that:

  • human judgments became reusable tests,
  • a changed boundary required a fresh Agent Challenge,
  • approval referred only to the exact state the human reviewed,
  • and an Agent could never silently approve or expand its own authority.

Another challenge was the Human-Agent handoff.

We did not want users to type tool names, revision numbers, or challenge scenarios manually. The browser therefore tells the user what happens next, where the next action takes place, and provides copy-ready handoffs when control moves back to ChatGPT.

Accomplishments that we're proud of

We built a complete Human-Agent governance loop through WebMCP.

The Agent can inspect, propose, challenge, and re-test changes to its delegation boundary, while the human retains final judgment and approval.

Human judgments do not disappear after one decision. They become regression tests that constrain future revisions.

We also made the Agent capability surface depend on human authority: five normal tools are available during collaboration, and the apply capability becomes available only after explicit human approval of the exact current revision.

Most importantly, WebMCP is not used here simply as a remote-control layer for a website.

It is part of the mechanism that separates Agent action from human authority.

What we learned

Building AI Delegation Boundary changed how we think about WebMCP.

The interesting part is not simply that an AI Agent can operate a website.

A web application can hold state, constraints, and authority while an Agent reasons and acts through that surface.

This allows the collaboration itself to be designed:

  • what the Agent may change,
  • what it must challenge,
  • when it must stop,
  • what only a human may decide,
  • and when additional capability may become available.

For us, WebMCP became a way to connect Agent reasoning with a governed web surface.

What's next for AI Delegation Boundary

AI Delegation Boundary is a focused implementation of a broader problem we are exploring through SOLIFAN and ReadinessOps:

How can organizations expand the practical use of AI Agents while deliberately retaining the judgments and authority that should remain human?

Next, we want to connect this model to real organizational workflows, richer evidence, additional delegation factors, and reusable governance patterns across different Agent environments.

The long-term goal is to make Agent authority something organizations can deliberately:

Design → Test → Approve → Evolve

Built With

Share this project:

Updates

Submission history