Proof Gate

Most competitors build intelligent agents. Proof Gate builds accountable intelligence.

Proof Gate is a WebMCP-native evidence workspace where a human and a browsing agent build the same versioned case together.

The contradiction is simple: web agents can often click and act, but they struggle to preserve shared state, provenance, uncertainty, and decision lineage across a real workflow.

Why WebMCP

Claim evaluation is stateful. A case contains a claim revision, decision context, evidence records, provenance, conflicts, a deterministic verdict, and an audit lineage. Without a structured application interface, a browsing model has to infer that state from DOM controls and maintain a separate copy.

Proof Gate exposes six narrow tools through document.modelContext.registerTool(...):

• read the current case
• set or revise the claim
• add evidence
• identify conflicts
• evaluate the current claim revision
• export the versioned record

The human and the agent operate on the same application state. The agent does not maintain a hidden parallel case, and the human does not have to trust a black-box conclusion.

Distillation Protocol: the governance boundary

Proof Gate applies a two-way Distillation Protocol at the boundary between the web and the governed case.

Inbound: raw user input, tool output, and external observations are converted into structured evidence with provenance, revision binding, uncertainty labels, and explicit source roles before they enter the case.

Outbound: internal evaluations and proposed actions are converted into scoped, inspectable outputs. Evidence-derived content is marked as untrusted, and no raw external statement becomes authority merely because an API, tool, user, or model asserted it.

This prevents four common failures:

• prompt or content injection becoming governance state
• API responses being mistaken for independently verified reality
• AI conclusions being silently promoted to facts
• stale or contradictory evidence being overwritten instead of preserved

The anti-magic rule is: I do not know yet, and here is exactly what evidence would resolve it.

Global Compass signature

Proof Gate follows the Global Compass design philosophy:

SEE REALITY → PRESERVE EVIDENCE → UNDERSTAND RELATIONSHIPS → SEPARATE CAPABILITY FROM AUTHORITY → VERIFY WHAT ACTUALLY HAPPENED → LEARN WITHOUT REWRITING HISTORY

In this application that means:

• evidence is bound to explicit claim revisions
• duplicate source families do not manufacture independence
• context records do not inflate support or refutation confidence
• unknown dates remain unknown and future dates are rejected
• contradictory evidence stays visible instead of being silently overwritten
• only HTTP/HTTPS evidence URLs are accepted
• evidence-derived WebMCP outputs are marked as untrusted content
• conflicts are aggregated and the evidence ledger is bounded
• the evaluator does not claim to independently establish truth

Better human + agent collaboration

Before WebMCP, an agent interacting with a case workspace has to reverse-engineer controls and reconstruct application state from the page. With WebMCP, the application exposes the actual operations and schemas directly.

The division of labor is explicit:

Human: frames the claim, inspects evidence, corrects context, challenges conclusions, and retains authority over meaningful decisions.

Agent: structures evidence, detects conflicts, evaluates the current revision, and prepares an export.

Application: deterministically enforces revision boundaries, validates inputs, and preserves the lineage both sides can inspect.

The agent can therefore be useful without becoming an unaccountable source of truth.

Reality Triangle

Proof Gate distinguishes three states instead of collapsing them:

• Intended: what the claim or decision asks us to establish
• Reported: what a source, tool, or provider says happened
• Observed: what the accumulated evidence actually supports

Success is not established merely because a tool returned success or a model produced a confident answer.

Implementation

The WebMCP layer calls the same pure JavaScript evidence engine used by the visible human UI. Tool calls and UI actions mutate the same state. Where supported, the application also checks getTools() enumeration after registration.

The evaluator is deliberately modest. Thresholds and source-family grouping are transparent demo heuristics rather than claims of calibrated universal truth.

Scope

Proof Gate is deliberately one focused web application, not an AI backend disguised as a hackathon entry. The demonstration is shared application state: explicit schemas for the agent, visible and revisable evidence for the human, deterministic evaluation, a governed boundary, and a versioned record they can inspect together.

Accountable intelligence, not merely intelligent agents.

Built With

• base44
• chatgpt
• css
• github
• html
• javascript
• webmcp