Diamond Control

A human-gated agent workspace where WebMCP lets agents read, recommend, and prepare actions without taking the final decision away from the person.

Comment

Inspiration

AI systems are becoming more capable very quickly. But greater capability also creates a new problem.

As tasks become longer and the amount of context grows, it becomes harder for an AI system to maintain reliable reasoning across everything it has to process. Important details can be missed, reasoning can drift, and hallucinations can become harder to detect.

That is why I believe greater AI capability should be paired with clearer Human Gates.

Diamond Control started from this idea: let the agent do as much useful work as possible, but keep explicit Human checkpoints at the decisions where correctness, authority, or risk really matter.

I did not want the Human to approve every small step. I wanted the AI to be able to work independently until it reaches a decision that genuinely belongs to the person.

What it does

Diamond Control is a human-gated agent workspace built with WebMCP.

It gives an AI agent a structured way to understand the current workflow, identify what needs attention, recommend a bounded next move, prepare that action, and request Human review.

The application exposes five WebMCP tools:

  1. get_workspace_state
  2. get_attention_items
  3. recommend_next_move
  4. prepare_action
  5. request_human_gate

The first three tools read or recommend without changing the workflow.

prepare_action can create a reversible proposed action, and request_human_gate can move that proposal into AWAITING_HUMAN.

But no WebMCP tool can approve or reject an action.

The final decision remains in the visible Human Gate.

In the demo, the agent identifies the proof-repair lane, recommends Review and run proof validation, prepares the proposal, and requests Human review.

The workflow enters AWAITING_HUMAN, where the agent stops.

The Human then chooses Reject, and Diamond Control produces a NO_ACTION proof receipt showing that the decision was made by the Human.

How I built it

Diamond Control is a browser-based application built with TypeScript/JavaScript, HTML, CSS, and WebMCP.

The main design goal was not simply to connect an AI agent to a web interface. I wanted the workflow itself to expose enough structure that the agent would not have to guess what the page means from buttons and text alone.

WebMCP provides explicit tools for:

  • reading workflow state
  • discovering items that need attention
  • recommending a next move
  • preparing a bounded action
  • requesting Human review

Behind those tools is a small state model that separates agent preparation from Human authority.

A proposal can move through states such as PROPOSED and AWAITING_HUMAN, but only the visible Human controls can produce an APPROVED or REJECTED decision.

I also added a fail-closed rule: if one proposal is already waiting at the Human Gate, the agent cannot silently replace it with another proposal. The Human must resolve the existing decision first.

The project is intentionally browser-side and small. It does not depend on a backend, database, authentication system, private user records, or an automatic approval service.

Challenges I ran into

The main challenge was not making the agent more capable.

The harder problem was deciding exactly where that capability should stop.

I had to separate several concepts that can easily become mixed together in an AI workflow:

  • reading information versus changing state
  • recommending an action versus executing a decision
  • preparing work versus authorizing it
  • agent capability versus Human authority
  • successful automation versus correct execution

Another challenge was making the boundary visible and testable rather than keeping it as an instruction written only in a prompt.

That is why Diamond Control uses explicit workflow states, a visible Human Gate, and a proof receipt after the decision.

I also learned that long AI workflows need clear checkpoints. If every small action requires Human confirmation, the system becomes too manual. But if the AI is allowed to continue without clear boundaries, it becomes difficult to know when Human judgment is actually required.

Finding that balance became the central design problem of the project.

Accomplishments that I'm proud of

I am proud that Diamond Control demonstrates a complete agent-to-Human workflow rather than only exposing a collection of WebMCP tools.

The demo shows a natural-language request moving through the entire process:

  • the agent reads the workspace
  • identifies what needs attention
  • recommends one next move
  • prepares the action
  • requests Human review
  • stops at AWAITING_HUMAN
  • the Human makes the final decision
  • the system produces a proof receipt

I am also proud that the authority boundary is enforced by the application itself.

The agent cannot approve or reject an action, and it cannot replace another proposal while an unresolved Human Gate is open.

For me, this is important because Human control should not depend only on asking an AI model to behave correctly. The workflow should make the boundary explicit.

What I learned

I learned that WebMCP becomes much more useful when it gives an AI agent a flexible, structured way to understand and interact with a workflow, instead of limiting the interaction to a small set of rigid buttons.

A good agent interface should expose meaningful state, available actions, constraints, and decision boundaries.

This allows the AI to adapt its help to the situation while still operating inside explicit rules.

For me, the value of WebMCP is not just automation.

It is making the collaboration between the Human, the interface, and the AI more flexible without losing control.

I also learned that giving an agent more autonomy does not necessarily mean giving it more authority.

Those are two different things, and separating them can allow an AI system to do substantially more work while still preserving the decisions that should remain Human.

What's next for Diamond Control

The next step is to make the boundaries between autonomous AI work and Human authority much more complete and explicit.

With stronger boundaries, agents should be able to run longer tasks on their own, carry work across multiple steps, and automatically bring the workflow to the correct Human Gate when a real decision is required.

The goal is to reduce unnecessary manual coordination.

Humans should not have to supervise every small step. They should be asked to intervene only at clear checkpoints where judgment, authority, or risk actually matters.

Over time, I would also like to extend the same pattern to more complex workflows, more types of actions, stronger proof and recovery mechanisms, and multiple agent environments.

If these boundaries are designed well, AI agents can become more autonomous while execution still remains aligned with the correct level of Human authority.

Built With

Share this project:

Updates

Submission history