Agent Accountability · Checks for the person who answers for what agents do

Know who answers for every agent action.

When an agent acts for you, a few questions decide who answers for the result: does a refund follow a rule written before checkout, does each recorded action name the agent, its authorization and its permissions, does a standing limit hold against an approval given in the moment, do the payment numbers reflect real commerce, does the agent choose its money for each payment, does run state stay apart from durable memory, does its identity hold outside the platform that issued it, and does every tool call pass the gateway. Agent Accountability answers them with eight tools: eight checks. Your agent sends the rules, records, design or definition in the call, and each tool returns a signed report with every status, match and verdict decided from it.

See the tools Read the contract

Tool access: 0.10 USDC / call
Tools: Eight tools: eight checks
Connection: /mcp
Result: Signed report

The eight tools.

Each tool reads one kind of accountability material and answers one question about it. The report names the term, action, override, number, filter, crossing, capability or tool path behind every status, so your agent and you can see why it reads the way it does.

`wever_refund-rule-check`

Reads: A checkout or payment setup's refund terms: when the rule is fixed, who may ask, how a request is decided, the window, where the money goes, and the checkout steps with what each records.
The signed report states: Whether a refund rule exists before checkout, whether the refund destination is captured at checkout, and every gap that would turn a refund into a one-off negotiation, with the fix for each.
Price: 0.10 USDC per call
Verdicts: no_standing_rulenegotiation_gapsrule_before_checkout

`wever_actor-attribution-check`

Reads: An action or audit record design: for each kind of action, how the record names the actor, the authorization, the permissions held and the time.
The signed report states: Every recorded action that cannot be tied to one agent acting under one authorization with the permissions it held at that moment, and the missing field in each case.
Price: 0.10 USDC per call
Verdicts: unattributable_actionsattribution_unverifiedattributable

`wever_approval-policy-check`

Reads: A spend-control design with momentary approvals and standing limits set in advance, the rule for when the two conflict, the exception path and the execution paths.
The signed report states: Whether approvals and standing limits are two different things, which one wins when a one-off approval exceeds a standing limit, and every path where approving in the moment quietly overrides policy set in advance.
Price: 0.10 USDC per call
Verdicts: approval_overrides_policyconflict_unresolvedpolicy_holds

`wever_volume-quality-check`

Reads: A payments activity report or metrics definition: each headline number, what it counts, how it is computed and what it leaves out.
The signed report states: Whether settled value is reported apart from transaction churn, whether self-payments and test payments are left out, whether payers are distinct wallets paying with their own money, and every headline number that can rise with no commerce behind it.
Price: 0.10 USDC per call
Verdicts: inflatablequality_unverifiedcommerce_backed

`wever_money-choice-check`

Reads: How an agent picks the money it pays with: the instruments it holds, the filters the design names, such as reversibility, redemption risk and liability, and the rule that picks one for each payment.
The signed report states: Whether the choice applies the stated filters to each payment or falls back to one hardcoded default, and every filter the design claims and never applies.
Price: 0.10 USDC per call
Verdicts: hardcoded_defaultfilters_unappliedchoice_unverifiedchosen_per_payment

`wever_memory-separation-check`

Reads: Where an agent keeps run state and durable memory, what each is keyed by and when it is cleared, every crossing between them, what happens when a run fails and whether runs overlap.
The signed report states: Whether run state and durable memory stay apart through the run lifecycle, every crossing into durable memory and whether it is deliberate, and every point where the two mix.
Price: 0.10 USDC per call
Verdicts: mixedboundary_unverifiedseparated

`wever_identity-portability-check`

Reads: An agent identity setup: the issuer, who holds the keys, how others verify it, how it exports, who can revoke it, the platforms that accept it and what it carries.
The signed report states: Whether the identity can be presented and verified outside its issuing platform, what breaks if the issuer revokes it or the platform closes the door, and every capability tied to a platform account with no export path.
Price: 0.10 USDC per call
Verdicts: platform_lockedpartly_portableportable

`wever_gateway-coverage-check`

Reads: An MCP or tool-access architecture: the gateway, its checks and what decides allow or deny, and every tool with how it is reached and where its calls are traced.
The signed report states: Every tool path that skips the gateway's deterministic checks, every tool reachable both through the gateway and directly, and whether tracing covers the paths that skip it.
Price: 0.10 USDC per call
Verdicts: unmediated_pathscoverage_unverifiedfully_mediated

How agents and people use it.

Your agent

Keeps the material each check reads: its refund terms and checkout steps, its action record design, its spend controls with their approvals and standing limits, the metrics it reports, its money selection rule, its memory stores, its identity setup and its tool-access architecture.
Calls the check that answers the question on https://weverlabs.com/mcp at the moment it matters: before a checkout goes live, when an audit log changes, before a spend policy ships, before a metrics report goes out, when a new instrument is added, when memory is redesigned, before it relies on a platform identity and when a tool is connected.
Acts on the verdict and keeps the signed report with the work, so the next step starts from a record.

You

See each gap named with the change that closes it.
Know which refunds follow a rule, which actions trace to one agent and one authorization, and which tool calls pass the gateway.
Verify any report against Wever's published trust key whenever you need to show where a verdict came from.

A worked example

Approved in the moment. Limited in advance.

The request

{
  "name": "wever_approval-policy-check",
  "arguments": {
    "approvals": {
      "approvers": [
        "CFO"
      ],
      "checked": "at_execution",
      "raises_limit": false
    },
    "policies": [
      {
        "name": "Vendor payment limit",
        "limit": "5,000 USD",
        "scope": "per_action",
        "changed_by": [
          "Finance committee"
        ]
      }
    ],
    "conflict_rule": "latest_wins",
    "exception": {
      "approvers": [
        "Finance committee"
      ],
      "recorded": false,
      "single_use": true
    },
    "paths": [
      {
        "name": "Payments API",
        "checks_policy": true
      },
      {
        "name": "Manual wire",
        "checks_policy": false
      }
    ]
  }
}

What the report returns

Verdict: approval_overrides_policy.

Override, latest wins	The later instruction governs, and an approval always comes after a limit set in advance, so the approval governs. Nothing records which limit it lifted.
Override, unrecorded exception	Finance committee may approve above a limit, and the exception is not recorded with the limit it lifts, so the override leaves no trace.
Override, unchecked path	The Manual wire path executes approved payments without checking the standing limits.
Fix, latest wins	Make the standing limit govern every conflict, and route a payment above it through a named exception path.
Fix, unrecorded exception	Record each exception with the approver, the limit it lifts and the action it covers.
Fix, unchecked path	Check the standing limits on the Manual wire path before execution.

3 ways approving in the moment overrides policy set in advance: latest wins, unrecorded exception and unchecked path.

The CFO approves a 10,000 USD vendor payment. The finance committee set a 5,000 USD limit per payment in advance. Under a latest-wins rule the approval governs, because an approval always comes after a limit set in advance, and the exception leaves no record of the limit it lifted. The manual wire path never checks the limit at all. Making the standing limit govern every conflict, recording each exception with the limit it lifts and checking the limit on every path keeps the policy in force.

Call it from your agent.

Connect to https://weverlabs.com/mcp and call any of the eight tools. Each call costs 0.10 USDC on Base. Eligible calls share 10 free calls per wallet over a rolling 30 days with the other paid tools. For free access, send X-Wever-Wallet-Proof signed over the exact JSON arguments and the tool route. The payment challenge supplies the x402 terms for a paid call.

Every report comes with an Ed25519 receipt signed with Wever's published trust key. The Agent Accountability contract lists the schemas, limits, verdicts and signing details. For firewall order, registries and approval durability, Agent Control; for policy precedence and memory design, Agent Oversight; for run records and money fit, Agent Readiness.

Browse all tools