Olympus MCP Harness

The model reasons. WebMCP connects. Olympus controls. The machine executes

Comment

Inspiration

AI models are good at reasoning, but execution should be controlled, observable, and reliable.

Olympus MCP Harness started from one simple idea:

“The model reasons. The machine executes.”

As WebMCP moves AI agents from reading websites to acting on them, execution becomes a trust boundary. Olympus was built to engineer that boundary.

Why WebMCP

WebMCP turns website capabilities into structured tools that agents can invoke directly instead of guessing their way through the UI.

Olympus builds on that boundary:

WebMCP structures the action. Olympus governs the execution.

Unlike a backend MCP integration, WebMCP works inside the live page and shared user session. Olympus uses that browser-native boundary to govern execution without replacing the existing web experience.

WebMCP defines how an agent can interact with the application, while Olympus determines whether an invocation is valid, allowed, safe to execute, and successfully completed.

What it does

Olympus MCP Harness is the execution control layer behind WebMCP.

WebMCP handles the agent-to-web boundary through structured tools. Olympus then:

  • Inspects the invoked capability
  • Validates tool arguments
  • Authorizes execution according to risk and policy
  • Executes the machine action
  • Verifies the result
  • Recovers from safe failures when appropriate
  • Traces the full execution path

High-risk actions, such as checkout, remain behind explicit human approval.

People + agents together

Olympus enables controlled delegation.

A user can delegate an outcome instead of manually operating every interface step. The agent reasons, discovers WebMCP tools, searches, compares, and prepares actions. Olympus governs execution, while the human only needs to intervene when a high-risk action requires approval.

This creates a new interaction model: agents can autonomously handle routine actions while humans remain in control of consequential ones.

The goal is neither full autonomy nor manual browsing. It is controlled delegation.

In the demo, the agent can search, inspect, compare, and prepare a laptop purchase through WebMCP tools, while Olympus keeps checkout behind an explicit approval boundary.

Who It's For

E-commerce and retail web apps: Olympus demonstrates how AI agents can safely help users search products, compare options, prepare a cart, and approach checkout without turning high-risk purchase actions into blind automation.

WebMCP developers: developers exposing real actions to AI agents and needing a reliable layer for validation, authorization, approval, recovery, verification, and observability.

Human users and judges: they can see the current model decision, harness stage, machine action, execution trace, and a non-skippable approval gate for high-risk actions.

WebMCP-capable agents and clients: such as ChatGPT’s in-app browser or Chrome with WebMCP enabled. The agent interacts through document.modelContext tools rather than relying on brittle UI actuation for the core workflow. The laptop storefront is the concrete retail demo; the harness pattern is designed to generalize to other WebMCP workflows.

How we built it

I built Olympus using the native WebMCP imperative API with: document.modelContext.registerTool(...)

The app exposes five structured tools:

  • search_products
  • get_product
  • compare_products
  • add_to_cart
  • checkout

Each WebMCP tool is intentionally thin and routes execution through the same Olympus harness.run(...) path, where validation, policy, approval, execution, recovery, verification, and tracing are enforced.

The application is built with Next.js, React, TypeScript, and deployed on Vercel.

Olympus runs behind WebMCP site tools inside the live browser context, preserving the page’s existing state and user experience while adding execution policy, verification, and traceability.

Tested natively with ChatGPT’s in-app browser

Olympus was tested directly in ChatGPT’s in-app browser.

ChatGPT successfully discovered and invoked these Olympus WebMCP tools natively:

  • search_products
  • get_product
  • compare_products
  • add_to_cart

For the high-risk checkout tool, ChatGPT’s own browser security blocked the invocation before it reached Olympus’s approval layer.

This demonstrates defense in depth:

ChatGPT Agent
      ↓
Client / Browser Security
      ↓
WebMCP
      ↓
Olympus MCP Harness
      ↓
Human Approval
      ↓
Machine

Low- and medium-risk actions successfully reached Olympus. High-risk checkout was independently blocked earlier by the client security layer.

To demonstrate Olympus’s own checkout approval flow, judges can use the live simulator or a WebMCP-enabled Chrome environment where the invocation is permitted.

Challenges we ran into

The main challenges were working with a rapidly evolving WebMCP runtime, clearly separating WebMCP responsibilities from harness responsibilities, and designing approval and recovery behavior without turning Olympus into another agent framework.

A key architectural decision was that WebMCP owns registration, discovery, and invocation, while Olympus operates behind that boundary to inspect and control execution.

Accomplishments that we're proud of

I’m proud that Olympus demonstrates:

  • native WebMCP integration
  • five structured WebMCP tools
  • a shared execution harness behind every tool
  • schema validation and policy-aware authorization
  • explicit human approval for high-risk actions
  • real execution traces and metrics
  • result verification
  • safe failure handling and recovery
  • native testing with ChatGPT’s in-app browser

The project is designed so the harness is more than a logging layer: it can actively prevent or gate machine execution.

What we learned

WebMCP provides a structured way for models to interact with websites, but exposing a tool is not the same as executing it reliably.

Reliable agent execution needs an additional engineering layer for validation, authorization, human approval, failure recovery, result verification, and observability.

In short:

WebMCP makes actions available to models. Olympus makes those actions safe to execute.

What's next for Olympus MCP Harness

Next, I want to evolve Olympus into a reusable execution harness for more WebMCP applications.

Future work includes:

  • richer policy models
  • reusable tool registration and policy APIs
  • stronger observability
  • broader failure and recovery strategies
  • support for more real-world WebMCP workflows
  • comparative reliability evaluation using Chrome WebMCP Evals methodology

I will only publish benchmark percentages after running real repeatable evals. The current project does not claim an unmeasured reliability score.

Closing

  • Project: Olympus MCP Harness
  • Philosophy: The model reasons. The machine executes.
  • Product thesis: The model reasons. WebMCP connects. Olympus controls. The machine executes.
  • Technical thesis: WebMCP defines the boundary. Olympus MCP Harness engineers the execution behind it.
  • Mission: Engineer the boundary between AI reasoning and machine execution.
  • Evaluation principle: I don't claim the harness improves reliability until I measure it.
  • The planned comparative evaluation is: Without Olympus Harness vs. With Olympus Harness, using fixed tasks and reporting real results only.

The future isn’t just better models. It’s better AI systems.🚀

Olympus MCP Harness is one attempt to make that system boundary visible, controllable, and reliable.

Checklist

- Native WebMCP integration         ✓
- Olympus controls execution       ✓
- Client-side security observed    ✓
- Human approval works             ✓
- Trace and metrics work           ✓
- Verification works               ✓
- Safe recovery works              ✓
- ChatGPT in-app browser tested    ✓
- No fake benchmark claims         ✓

Built With

  • ai-agents
  • ai-safety
  • chatgpt
  • chrome
  • harness
  • hitl
  • human-in-the-loop
  • mcp
  • openai
  • vercel
  • webmcp
Share this project:

Updates

Submission history