Agent Recovery · Checks for whether a system recovers soundly when a task is interrupted or fails

A recovery is sound when the work resumes.

A system recovers soundly when an interrupted task picks up from a recorded point, retries follow one stated plan, half-done work shows as half done, every effect has its undo written in advance, the principal hears of a failure from the system, the agent agrees with the system's record before working again, every recovery is written down, and anything a recovery repeats is caught before it goes out twice. Agent Recovery checks each of those with eight tools: eight checks. Your agent sends the steps, retry plans, state reports, effects, notices, recovery flows, recovery records or retry flows 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 recovery material and answers one question about it. The report names the step, plan, call, task, effect, notice, piece of state, record or run behind every status, so your agent and you can see why it reads the way it does.

`wever_resume-point-check`

Reads: A task system: each step in order with whether finishing it writes a record a resumed run reads and what it costs to run again, what happens after an interruption, where the progress record lives and what it names, with the interruptions seen.
The signed report states: Whether an interrupted task resumes from a recorded point or starts over, with every step that records nothing, every run that started again or redid finished steps, and the cost re-spent.
Price: 0.10 USDC per call
Verdicts: work_restartsresume_gapsresume_unverifiedresumes_from_record

`wever_retry-plan-check`

Reads: A system’s retry behavior: the standing plan with its attempts, spacing, waits, time limit, failures never retried and what happens when retrying stops, with the calls that retry on their own terms and the failures the system sees.
The signed report states: The plan’s attempts, spacing and stop point, then every missing bound, every stop nobody hears of, every failure retried that retrying cannot fix and every call retrying outside the plan.
Price: 0.10 USDC per call
Verdicts: retries_blindretry_plan_gapsretry_plan_unverifiedretry_plan_stated

`wever_partial-state-check`

Reads: A task system’s state reporting: whether it has a state for partly done work, what lets a task read as done and what a mid-task failure shows, with the tasks it reported on piece by piece.
The signed report states: Whether half-done work shows as partly done with its missing pieces named, or reads as finished, with every task reported done while pieces were unfinished.
Price: 0.10 USDC per call
Verdicts: half_done_looks_donepartial_state_gapspartial_state_unverifiedpartial_shown_as_partial

`wever_rollback-path-check`

Reads: The effects a task can leave outside itself, each with how it is undone, the reversal as written, its window, whether it is marked irreversible up front, whether it waits for approval and when the reversal was written.
The signed report states: For each effect whether it can be reversed and whether that reversal was written before the first failure, with every effect marked irreversible up front and every one nobody marked.
Price: 0.10 USDC per call
Verdicts: undo_undefinedrollback_gapsrollback_unverifiedundo_defined

`wever_failure-notice-check`

Reads: A failure-handling flow: who the task is done for, how soon they should hear, and each notice with who it reaches, how fast and what it says, with the failures seen and how the principal heard of each.
The signed report states: Who is told when a task fails for good, how fast and with what detail, with every failure the principal found out about on their own.
Price: 0.10 USDC per call
Verdicts: principal_finds_outnotice_gapsnotice_unverifiedprincipal_told

`wever_state-reconciliation-check`

Reads: A recovery flow: each piece of state the agent works from, the system record it is checked against, when the check runs after an interruption and what happens on a difference, with the recoveries seen.
The signed report states: Whether the agent and the system agree on balances, task states and sent items before new work starts, or the agent resumes on its own stale picture.
Price: 0.10 USDC per call
Verdicts: resumes_on_stale_statereconciliation_gapsreconciliation_unverifiedreconciled_before_work

`wever_recovery-record-check`

Reads: A system’s recovery records, each with the task, when it was interrupted, what failed, what was done, what was lost and what changed afterward, beside the interruptions seen in other logs.
The signed report states: How many recoveries keep the essentials, every record missing what failed, what was done, what was lost or what changed, and every interruption nobody wrote down.
Price: 0.10 USDC per call
Verdicts: recoveries_unrecordedrecord_gapsrecords_unverifiedrecoveries_recorded

`wever_duplicate-effect-check`

Reads: A resume and retry flow: each effect a resumed or retried task can repeat, with how a repeat is stopped or caught, what one idempotency key covers and whether the flow looks for the effect after recovery, with the runs seen.
The signed report states: Effect by effect, whether messages, orders, records and bookings a recovery repeats are stopped or caught, with every effect seen happening twice.
Price: 0.10 USDC per call
Verdicts: effects_can_repeatduplicate_gapsduplicate_unverifiedduplicates_checked

Start with the two free tools.

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

`wever_resume-snapshot`

Reads: One task’s recovery state: where it stopped, what is recorded as done and what remains.
Returns: The recovery state as one plain record, each part in plain words or not stated.
Access: Free on /mcp-free

`wever_retry-plan-sample`

Reads: One retry plan’s headline: whether it is written down, its attempts, spacing and waits, its time limit and what happens when retrying stops.
Returns: Whether a stated retry plan exists, with its attempts, spacing and stop point. The retry plan check gives the full audit.
Access: Free on /mcp-free

How agents and people use it.

Your agent

Records where a task stands with wever_resume-snapshot each time it stops, so the next run, the owner and the principal start from one plain record of where it stopped, what is done and what remains.
Calls the check that answers the question on https://weverlabs.com/mcp at the moment it matters: when it designs a task's steps, a retry plan or a failure flow, before it adds an effect with no undo, after an interruption and before new work starts, when a task fails for good, and on each review of the system's recoveries.
Acts on the verdict and keeps the signed report with the flow, so the next change starts from a record.

You

See each gap named with the change that closes it.
Know whether an interrupted task picks up or starts over, how retries stop and who hears, whether a half-done task reads as done, what can be undone, and whether anything went out twice.
Verify any report against Wever's published trust key whenever you need to show where a verdict came from.

A worked example

A trip reported done. The hotel was never booked.

The request

{
  "name": "wever_partial-state-check",
  "arguments": {
    "system": "booking pipeline",
    "reporting": {
      "partial_state": true,
      "names_missing": true,
      "done_when": "no_error",
      "on_mid_task_failure": "reports_partial"
    },
    "tasks": [
      {
        "id": "trip-7",
        "reported": "done",
        "parts": [
          {
            "name": "flights held",
            "completed": true
          },
          {
            "name": "hotel booked",
            "completed": false
          }
        ]
      }
    ]
  }
}

What the report returns

Verdict: half_done_looks_done.

Finding, done on no error	A task that returns without an error is marked done, whatever it delivered.
Finding, done but partial	trip-7 was reported done with 1 piece of 2 unfinished: hotel booked.
Fix, state reporting	Report done only when every part of the task is confirmed, not when no error is raised.
Fix, trip-7	Correct trip-7 to partly done, name its unfinished pieces, and confirm every part before reporting done.

Half-done work can present as finished: done on no error and done but partial (trip-7).

The pipeline holds the flights, then the hotel call fails partway. The system marks a task done whenever it returns without an error, so trip-7 reads as finished while the hotel sits unbooked. The report names both, so the owner has done wait for every piece to be confirmed and corrects trip-7 to partly done, with the hotel named as the missing piece.

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 Recovery contract lists the schemas, limits, verdicts and signing details. For one paid call's delivered result and double charges, Agent Purchases; for retry safety and kill switches, Agent Readiness; for handoff failure paths, Agent Handoffs; for job handoff packs and payment recovery, Job Records.

Browse all tools