Agent Limits · Checks for whether an agent's limits hold

A limit in code is a wall.

An agent's limits hold when code it cannot rewrite enforces them, when each fits the work it governs, when changing one takes an owner, when they are reviewed as the work changes, and when hitting one sends the work somewhere defined. Agent Limits checks each of those with eight tools: eight checks. They cover what enforces each limit, whether limits are scoped per task and per merchant, who can raise or suspend a limit, whether thresholds are reviewed on a schedule, what happens at the wall, whether a cap shared by several agents is counted in one place, whether the agent and the owner see a limit before they hit it, and whether each limit event left a usable record. Your agent sends the limits, work, change paths, reviews, breach paths, shared cap, views or event records 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 limit material and answers one question about it. The report names the limit, job, path, threshold, agent, view or event behind every status, so your agent and you can see why it reads the way it does.

`wever_limit-substrate-check`

Reads: An agent's limits, the numeric and action ceilings it runs under, each with every place it is enforced or stated, the running total it is checked against, whether the agent can change the enforcing layer and what that layer does when it is down.
The signed report states: Which limits are walls in code, a gateway, the platform or a wallet policy the agent cannot rewrite, and which are suggestions resting on a prompt, a tool description or the model's own judgment, with every rewritable layer, self-reported total and layer that fails open.
Price: 0.10 USDC per call
Verdicts: limits_are_suggestionswalls_with_gapssubstrate_unverifiedlimits_enforced_outside_agent

`wever_limit-scope-check`

Reads: A limit set, each limit with its amount and what it applies to, beside the work it governs: each kind of job with its merchant, a typical amount and its largest legitimate amount.
The signed report states: The limit governing each job and whether it fits, every cap ten times or more above a job's size, every job whose routine amount is over its cap, every job no limit governs, and one cap doing every job.
Price: 0.10 USDC per call
Verdicts: one_cap_for_all_workscope_misfitscope_unverifiedscoped_to_work

`wever_limit-change-check`

Reads: Every path that raises, loosens, suspends, lowers or tightens a limit, with who can take it, where, when it is approved and when it is recorded, plus the limit changes recorded so far.
The signed report states: Every path that lets the agent widen its own limits or lets anyone change one, every widening approved late or never, every self-approval, every change recorded after it holds, and every recorded change the agent made to itself.
Price: 0.10 USDC per call
Verdicts: agent_controls_limitschange_gapschange_unverifiedchanges_owned

`wever_threshold-review-check`

Reads: A threshold set with each threshold's value, setup date, review owner, cadence and review history, plus the changes to the agent and its work since setup.
The signed report states: Every threshold never reviewed, on no schedule, past its review, with no owner or with a last review that left no decision, data or rationale, and every threshold the agent or its work has changed around.
Price: 0.10 USDC per call
Verdicts: thresholds_fossilizedreview_gapsreview_unverifiedreviewed_on_schedule

`wever_breach-path-check`

Reads: Each limit with what hitting it does to the work, who an escalation goes to, how long they have to answer, what happens on silence, who clears a queue, when the path was written and when the limit was first hit.
The signed report states: Whether each wall stops the work, escalates it to a named person or queues it for one, with every path that lets work continue, goes through on silence, reaches no named person, or was written down after the first breach.
Price: 0.10 USDC per call
Verdicts: wall_not_heldbreach_path_gapsbreach_path_unverifiedbreach_paths_defined

`wever_shared-cap-check`

Reads: One wallet, budget or quota shared by several agents or tasks, with where and when spending against it is counted, whether each spend is reserved first, what each agent reads its room from and how much it can spend in flight.
The signed report states: Whether the cap is counted in one place in real time, every way agents can drain it in parallel, how far the total can pass the cap, and any recorded spending over it.
Price: 0.10 USDC per call
Verdicts: cap_overshotcap_can_overshootaccounting_unverifiedaccounted_in_one_place

`wever_limit-visibility-check`

Reads: Each limit with what the agent and the owner can each read of it and when, where the remaining headroom shown comes from, and when anyone is warned.
The signed report states: Every limit the agent or the owner learns by hitting it, every side that sees a limit without its headroom or only after the money moves, every stale headroom and every wall with no warning before it.
Price: 0.10 USDC per call
Verdicts: limits_learned_by_hittingvisibility_gapsvisibility_unverifiedvisible_before_acting

`wever_limit-evidence-check`

Reads: The records of limit events: each block, escalation, queued action, near miss and override, with the limit, the attempt, the amount, the time, the response, who was told and who wrote the record.
The signed report states: How many events keep the essentials, every event missing which limit, what was attempted, when or what the system did, every event with no one told, every unknown limit name, every record the agent wrote itself and every silent override.
Price: 0.10 USDC per call
Verdicts: events_unreconstructableevidence_gapsevidence_unverifiedevents_reconstructable

Start with the two free tools.

On https://weverlabs.com/mcp-free, anonymous and with no wallet, two Agent Limits tools read an agent's limits at summary depth. Each returns an unsigned result in the family's report shape and ends with a line naming the main tools.

`wever_limit-scope-sample`

Reads: Up to ten of an agent's limits, each with what it applies to.
Returns: For each limit, whether it is scoped per task, per merchant, both or per agent, or is one global cap. The limit scope check gives the full fit to the work.
Access: Free on /mcp-free

`wever_limit-snapshot`

Reads: An agent's stated limits: each limit with its amount or threshold and its scope.
Returns: The limits as one plain list, each amount and scope in plain words or not stated.
Access: Free on /mcp-free

How agents and people use it.

Your agent

Lists its own limits first with wever_limit-snapshot, so it and its owner start from one plain list of each limit, its amount and its scope.
Calls the check that answers the question on https://weverlabs.com/mcp at the moment it matters: when its limits are set, when its work changes, when someone asks to raise a limit, on each scheduled threshold review, before it shares a wallet with other agents, when it hits a wall and when it closes out a breach or near miss.
Acts on the verdict and keeps the signed report with the limit set, so the next change starts from a record.

You

See each gap named with the change that closes it.
Know which limits are walls and which are suggestions, which fit the work, who can move them and where the work goes when one is hit.
Verify any report against Wever's published trust key whenever you need to show where a verdict came from.

A worked example

A cap in the prompt. A total the agent keeps.

The request

{
  "name": "wever_limit-substrate-check",
  "arguments": {
    "agent": "buyer-agent",
    "limits": [
      {
        "name": "Per payment",
        "kind": "per_payment",
        "amount": "50 USDC",
        "enforced_at": [
          "system_prompt"
        ]
      },
      {
        "name": "Daily",
        "kind": "per_period",
        "amount": "500 USDC",
        "enforced_at": [
          "gateway"
        ],
        "counter": "agent_reported",
        "agent_can_change": false,
        "on_failure": "closed"
      }
    ]
  }
}

What the report returns

Verdict: limits_are_suggestions.

Finding, prompt only	Per payment rests on the system prompt, which buyer-agent can read and still exceed.
Finding, self reported counter	Daily is checked by a gateway against a total the agent reports, so the agent decides how much room is left.
Fix, Per payment	Move Per payment into code, a gateway, a platform control or a wallet policy that checks every action, and keep the prompt text as a description only.
Fix, Daily	Check Daily against a total the enforcing layer keeps itself, not one the agent reports.

1 limit is a suggestion the agent can read and exceed: Per payment.

The agent runs under two limits. The per-payment cap lives only in its system prompt, so the agent reads it and can still pay past it. The daily cap sits in a gateway outside the agent's reach, and the gateway checks it against a running total the agent reports, so the agent still decides how much room is left. The report names both, so the owner moves the per-payment cap into the gateway and has the gateway keep its own total.

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 Limits contract lists the schemas, limits, verdicts and signing details. For budget controls and exposure caps, Agent Governance; for escalation thresholds and payment firewalls, Agent Control; for permissions enforced outside the model, Agent Access; for purchase records, Agent Purchases.

Browse all tools