IntentOS

An intent layer for AI agents that prevents conflicting actions and keeps humans in control.

Comment

The problem

AI agents are becoming better at taking actions, but people still have to trust those actions to match what they actually meant.

A user might tell an agent:

"Launch my landing page, but don't spend money, don't publish anything without my approval, and don't use fake testimonials."

Those instructions are easy for a human to understand. But when an agent starts working, the important question is not just "Can it complete the task?"

It is:

"Can it complete the task without violating what the human actually intended?"

Today, that agreement is often buried in chat history, scattered across settings, or left for the agent to infer. IntentOS explores a different approach: make the human's intent explicit, structured, and available to the agent as a set of tools.

What we built

IntentOS is a human intent layer for AI agents.

It lets a person define:

  • A goal
  • Non-negotiable constraints
  • Flexible preferences
  • Actions that require human approval

An agent can then use WebMCP tools to read that intent, propose actions, and receive an explainable verdict before proceeding.

The three possible outcomes are:

  • SAFE — the proposal fits the current intent.
  • REQUIRES_APPROVAL — the action is allowed only after the human decides.
  • CONFLICT — the proposal violates a non-negotiable constraint.

The important part is that a conflict does not silently disappear. It becomes a visible decision for the human.

The experience

Imagine a user creates this intent contract:

Launch a landing page for my AI automation service.

Budget must remain ₹0.

Do not use fake, fabricated, or unverified customer testimonials.

Publishing requires my approval.

The agent wants to improve the landing page.

First, it proposes:

"Add customer testimonials to increase visitor trust."

IntentOS evaluates the proposal and returns CONFLICT.

The human rejects it.

The agent then proposes:

"Add a What We Automate section instead of testimonials."

IntentOS evaluates the new proposal and returns SAFE.

Later, the agent proposes publishing the landing page. IntentOS returns REQUIRES_APPROVAL, so the human gets the final decision.

This is the experience we wanted to explore:

The agent can act independently, but it cannot quietly redefine the agreement.

Why WebMCP?

WebMCP makes this interaction possible in a more direct way.

Instead of an agent trying to navigate a dashboard, guess which buttons to click, or interpret unstructured page content, IntentOS exposes structured tools such as:

  • get_intent_state
  • create_intent_contract
  • add_constraint
  • propose_action
  • resolve_intent_conflict
  • update_intent_contract

These tools give the agent a clear interface for working with the user's intent.

The agent does not need to guess how to submit a proposal. It can call propose_action with a structured action and reason, receive a verdict, and then use the result to decide what to do next.

That is the core WebMCP idea we wanted to explore:

A website should not only be designed for people to click through. It should also expose meaningful capabilities that agents can use directly.

How we built it

IntentOS is a React + TypeScript application built with Vite.

The application has four main parts:

1. Intent Contract

A structured representation of the human's goal, constraints, preferences, and approval requirements.

2. Conflict Engine

A deterministic, explainable evaluation engine that checks agent proposals against the contract.

We deliberately kept this engine separate from the UI and did not use an LLM to decide whether a proposal violates a constraint.

For this prototype, we wanted the verdict to be predictable and understandable.

3. Human Approval Queue

When an agent proposes something that conflicts with the contract or requires approval, the proposal appears in a visible queue.

The human can approve or reject it.

The decision is recorded in the activity timeline.

4. WebMCP Integration

The application registers six tools through document.modelContext.registerTool().

The tools share the same state and action system as the UI, so the agent-facing interface and the human-facing interface operate on the same underlying contract.

We also built a clearly labeled development test harness for exercising the tool handlers during development.

What we learned

The biggest lesson was that agent autonomy and human control are not necessarily opposites.

An agent does not need to ask for permission before every small decision. It needs to understand which decisions it can make and which decisions belong to the human.

That distinction led us to separate:

  • Non-negotiable constraints — the agent may not violate them.
  • Flexible preferences — the agent may decide within them.
  • Approval-gated actions — the agent must wait for a human decision.

We also learned that WebMCP changes how we think about web application design.

The UI is no longer the only interface. A well-designed application can expose structured capabilities that make agent interaction more reliable and less dependent on guessing.

Challenges

The biggest technical challenge was working with an emerging browser API while keeping the application usable when WebMCP is unavailable.

We implemented feature detection and honest status reporting rather than pretending an agent was connected.

The application can still be used normally, while the WebMCP integration becomes available in a compatible browser environment.

Another challenge was making the conflict engine explainable.

A simple "blocked" message is not enough. The user needs to understand:

  • What the agent proposed
  • Which constraint was involved
  • Why the proposal was blocked
  • What decision the human can make

That is why IntentOS records proposals, verdicts, and human decisions in the activity timeline.

What is next

This prototype focuses on the interaction model: human intent → agent proposal → evaluation → human decision → agent adaptation.

The next step would be connecting IntentOS to a more capable agent that can use these tools across a real workflow, such as building and publishing a website, managing a project, or coordinating business tasks.

We believe the most useful agent-native applications will not simply give agents more power.

They will give agents better boundaries.

And those boundaries should be understandable to the people who define them.

Built for the WebMCP Challenge

IntentOS explores how a website can become more useful when humans and agents work together through structured tools.

The goal is not to replace human judgment.

It is to make that judgment explicit, reusable, and available at the moment an agent needs it.

Built With

Share this project:

Updates

Submission history