HUMANMIRROR / AGENT CONTROL PLANE

Control agent actions in production. Start in 14 days, without a card.

Start the Developer plan with 250k included requests and one API key. Use HumanMirror before consequential agent actions, then scale to Fleet when usage becomes recurrent. x402 pay-per-use remains available for machine-native buyers.

No card required. If no payment method is added during the trial, the subscription cancels instead of charging silently.
DUAL REVENUE / DUAL ACCESS

Subscribe for capacity. Pay per call when that is better.

Subscriptions and x402 are both first-class. Start Starter, Developer, Studio or Fleet with a 14-day trial — No card required. Add a payment method only if you decide to keep the subscription; otherwise the trial cancels safely. Agents can also use HumanMirror without a monthly plan through x402.

Need risk validation first? Audit one workflow · 299 €No card required for the 14-day trial. One trial per work email; no silent charge if no payment method is added. Start self-service now, then expand to Fleet or Enterprise Guard when the governed workload grows.
STARTER
29 €/mo
  • 50k included requests
  • 1 primary API key
  • 14-day checkout trial
PRO · COMPATIBILITY
49 €/mo
  • 100k included requests
  • 5 included API keys
  • Existing Pro contract retained
DEVELOPER
79 €/mo
  • 250k included requests
  • 1 primary API key
  • UTL + machine APIs
STUDIO
199 €/mo
  • 1M included requests
  • 10 included API keys
  • Agency / multi-agent use
FLEET
499 €/mo
  • 5M included requests
  • 50 included API keys
  • Fleet-scale integration
ENTERPRISE GUARD
1 500 → 5 000 €/mo
  • Governance and financial control plane
  • 25 → 500 active agents
  • 500k → 5M governed preflights
Deploy Enterprise Guard
x402 PAY-PER-USE
0.001 → 0.050 USDC/call
  • Base mainnet
  • No monthly subscription required
  • Machine-readable HTTP 402
Open machine catalog
TRANSACTION INTEGRITY + UNIVERSAL TRANSPORT

Put HumanMirror in the action path with one guarded fetch.

guardedFetch() creates a signed HumanMirror transaction binding before a consequential HTTP action, executes only after an ALLOW decision, then closes the binding as MATCH or DRIFT. The request body and query string stay client-side: HumanMirror receives structural metadata and SHA-256 digests, not your bearer tokens or raw payload. The binding endpoints require no HumanMirror account; production policy, fleet capacity and enterprise governance are paid layers.

import { createHumanMirror } from "@humanmirror/sdk";

const hm = createHumanMirror();

const response = await hm.guardedFetch(
  "https://vendor.example/orders",
  {
    method: "POST",
    headers: {
      "content-type": "application/json",
      "authorization": `Bearer ${process.env.VENDOR_TOKEN}`
    },
    body: JSON.stringify(order)
  },
  {
    intent: {
      objective: "Create approved vendor order",
      actor: "agent",
      amount: 25,
      currency: "USDC",
      destination: "0xApprovedVendor",
      constraints: { max_amount: 50 }
    },
    payment: {
      rail: "x402",
      amount: 25,
      currency: "USDC",
      destination: "0xApprovedVendor"
    }
  }
);

console.log(response.humanmirror.binding.decision); // ALLOW
console.log(response.humanmirror.closure.verdict);  // MATCH
Truth boundary. The signed binding proves what HumanMirror received and decided about the caller-declared intent, action digest, payment terms and authorization evidence. MATCH/DRIFT compares the caller-supplied observed execution against that binding. It does not independently prove legal authority, blockchain settlement, vendor delivery or external-world truth.

MCP 2026: guard a tool call without moving credentials.

guardedMcpFetch() reads the official MCP routing metadata (Mcp-Protocol-Version, Mcp-Method and optional Mcp-Name), sends only structural metadata plus request digests to the Universal Authorization Envelope, executes the original MCP request only after ALLOW, then closes the action as MATCH or DRIFT. The same neutral authorization surface can carry declared contexts from AP2 · UCP · MCP · A2A without claiming native protocol conformance or replacing the original authorization authority.

const response = await hm.guardedMcpFetch(
  "https://mcp.vendor.example/mcp",
  {
    method: "POST",
    headers: {
      "content-type": "application/json",
      "authorization": `Bearer ${process.env.VENDOR_TOKEN}`,
      "Mcp-Protocol-Version": "2026-07-28",
      "Mcp-Method": "tools/call",
      "Mcp-Name": "orders.create"
    },
    body: JSON.stringify(rpcCall)
  },
  {
    intent: { objective: "Create approved order", actor: "agent" },
    authorization: { scope: "orders:write" },
    policy: { max_amount: 50 }
  }
);

console.log(response.humanmirror.binding.decision); // ALLOW
console.log(response.humanmirror.closure.verdict);  // MATCH
Credential boundary. Vendor bearer tokens and the raw MCP request body stay on the caller side. HumanMirror receives the declared authorization context and SHA-256 request digests. For AP2, UCP, AAP or another native authorization system, supply only the evidence or reference you intend HumanMirror to bind; HumanMirror does not verify a native signature unless a dedicated verifier explicitly says it does.

For passive adoption first, HumanMirror Reflex remains a free fail-open Shadow Mode: POST /api/reflex/check/. No useful intervention = no charge.

Normalize → route → retry → fail over → preserve → replay.

The SDK stays client-side, so HumanMirror does not become an arbitrary open proxy. Compatible endpoints are explicitly configured by the developer or agent runtime.

PAYLOAD

Bounded syntax repair

Objects, JSON-like text, code-fenced JSON and unformatted text are converted into a stable JSON-safe payload without eval.

TRANSPORT

429 / 502 / 504 resilience

Bounded exponential retry, Retry-After support, endpoint scoring and circuit-breaker behavior route idempotent work across the configured pool.

STATE

Durable local fallback

Node journals pending work to JSONL. Python uses SQLite WAL. Replay preserves the original request ID to reduce duplicate execution risk.

Node / TypeScript

import { createHumanMirror } from "@humanmirror/sdk";

const hm = createHumanMirror();
const result = await hm.request("/api/one/run/", {
  method: "POST",
  payload: task,
  idempotent: true
});

Python

from humanmirror import create_humanmirror

hm = create_humanmirror()
result = hm.request(
    "/api/one/run/",
    method="POST",
    payload=task,
    idempotent=True,
)
Registry publication pending. The Node and Python SDKs are implemented, package-tested and served from HumanMirror today, but public npm/PyPI publication still requires the external registry accounts. Until then, use the live source directly:
# Node / TypeScript source
curl -fsSLo humanmirror.mjs https://humanmirror.fr/packages/humanmirror-sdk-js/index.js

# Python source
mkdir -p humanmirror && curl -fsSLo humanmirror/__init__.py https://humanmirror.fr/packages/humanmirror-sdk-python/humanmirror/__init__.py
The canonical future registry names remain @humanmirror/sdk and humanmirror.

X-Metrics-Sync: 1X-Request-IdIdempotency-Keylocal replayPANGI-ready

Availability boundary. The SDK can preserve pending state when local storage succeeds and can fail over among configured compatible endpoints. It cannot truthfully guarantee 100% execution continuity if every network path and every configured endpoint is unavailable.
BOOTSTRAP ZERO-FRICTION

Environment-aware by default.

HUMANMIRROR_API_KEY=...
HUMANMIRROR_BASE_URL=https://humanmirror.fr
HUMANMIRROR_FAILOVER_URLS=https://edge-a.example,https://edge-b.example
HUMANMIRROR_QUEUE_PATH=.humanmirror/transport-queue.jsonl

The SDK also reads .humanmirror.json. Environment variables take precedence, making the same package portable across local bots, CI runners, containers and fleet workers.