mcpField
W
WHP Standing

WHP Standing

Remote
standing-guard-service.lovable.appAI & Agents0Updated 1d ago

About WHP Standing

WHP Standing is middleware for autonomous AI agents that checks whether actions have sufficient authority and provenance before execution. It blocks unauthorized state changes, while allowing passive reads without blocking.

Key features

  1. 01Blocks state changes without authority or provenance
  2. 02Inspects decisions without throwing
  3. 03Enforces bounded authority windows
  4. 04Stops unbounded loops and recursion
  5. 05Allows passive reads without blocking

Use cases

  1. 01Guard an agent before a database write
  2. 02Prevent an unauthorized file deletion
  3. 03Inspect why a tool call was blocked
  4. 04Limit repeated or recursive agent actions

MCP support

The README describes middleware and a network evaluation service, but does not state that the project is an MCP server or specify an MCP connection.

Configuration

Remote servers need no local install. Pick your client, then copy the config or install in one click.

Endpointhttps://standing-guard-service.lovable.app/mcp
Copy install command
Claude CodeTerminal
Cursor.cursor/mcp.json
VS Code.vscode/mcp.json
Claude Desktopclaude_desktop_config.json
Windsurf~/.codeium/windsurf/mcp_config.json

Run commands in a terminal; paste JSON into the client’s MCP config and restart. Servers that need sign-in will prompt on first connect.

Tools

3

This tool takes no parameters.

Details

From the project README

@wheelerhubbell/whp-standing-client

Fail-closed epistemic standing middleware for autonomous AI agents.
Governed by the Authority Conservation Principle: $A(c) \le P(c)$ (Authority cannot exceed provenance).

Standing detects and stops Coherent Substitution—when an AI agent silently replaces the assigned task with an adjacent one ($q \to q^*$), reasons coherently about the replacement, and executes unauthorized state mutations.


📚 Case Studies & Theory

  • Coherent Substitution (v1.1): Theoretical formulation of proposition integrity and why systems fail before their reasoning becomes wrong.
  • Mata v. Avianca Epistemic Autopsy: Controlled forensic breakdown showing how an agent citing 100% verified sources still fails by answering the wrong question ($Q_0 \to Q_1$).

⚡ 1-Line Middleware Integration

Install the package:

npm install @wheelerhubbell/whp-standing-client

Place guardAction immediately before tool execution:

import { guardAction } from '@wheelerhubbell/whp-standing-client';

// Before any agent tool runs:
await guardAction(toolCall, {
  standing: executionContext.standing
});

// Proceed only if standing is warranted
return await tool.execute(toolCall.arguments);

If an agent attempts a state-changing operation (file deletion, database write, API mutation) without attributable upstream authorization or provenance, guardAction throws a StandingViolationError before the boundary is crossed.


🔍 Observability: evaluateStanding

For inspection without throwing:

import { evaluateStanding } from '@wheelerhubbell/whp-standing-client';

const decision = await evaluateStanding(toolCall, context);
if (!decision.allowed) {
  console.warn(`Blocked [${decision.code}]: ${decision.message}`);
  return decision;
}
Diagnostic Decision Object
{
  "allowed": false,
  "code": "MISSING_UPSTREAM_PROVENANCE",
  "actionId": "call_8cb2f1",
  "toolName": "delete_database_table",
  "required": ["authority", "provenance"],
  "observed": {
    "toolName": "delete_database_table",
    "arguments": { "table": "users" },
    "missing": ["provenance", "authority"]
  },
  "message": "Tool execution blocked for 'delete_database_table': no attributable upstream authorization or provenance."
}

🛡️ Core Semantics

  • Fail-Closed by Default: Any state-changing action missing valid provenance or authority is rejected.
  • Authority Windows: Bounded by valid_until timestamps.
  • Loop & Recursion Bounds: Halts unbounded agent loops (executionCount > maxExecutionCount).
  • Zero Overhead for Reads: Passive read operations execute without blocking.

🌐 Verifiable Network Verification

The live service has a plain front door for ordinary x402 agents: POST /v1/evaluate with subject, claim and optional provenance, priced at 1.00 USDC on Base (x402 v2). It returns a signed evaluation record. That record is not a sealed Standing Mark. Marks are issued through POST /v1/evaluations, which takes signed submissions per the published contract.

Example using the official x402 client (requires your own funded wallet and spending limits; not yet verified end to end against the live service):

import { x402Client, wrapFetchWithPayment } from '@x402/fetch';
import { registerExactEvmScheme } from '@x402/evm/exact/client';
import { privateKeyToAccount } from 'viem/accounts';

const client = new x402Client();
registerExactEvmScheme(client, { signer: privateKeyToAccount(process.env.EVM_PRIVATE_KEY) });
const fetchWithPayment = wrapFetchWithPayment(fetch, client);

const res = await fetchWithPayment('https://api.wheelerhubbellpublishing.com/v1/evaluate', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    subject: 'agent-session-42',
    claim: 'Agent executed system mutation',
    provenance: { source: 'user-intent', authority: 'admin' }
  })
});
console.log(await res.json());

Check the payment terms first with GET /v1/contract. The StandingClient class in this package does not sign or pay yet.


License

MIT © Wheeler Hubbell Publishing

Comments

Markdown supported

New to MCP?

From what the protocol is to installing your first server, these answers cover most first questions.

An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.