Agent Handoffs · Checks for whether work moves soundly between agents

A handoff is done when the receiver accepts.

Work moves soundly between agents when every handoff is written down, the receiver accepts before the sender lets go, the context travels with the task, the task reaches the agent it was meant for, a refusal has a road back, each hop leaves a trace, the organisation keeps one list of its agents, and the receiver gets the task's access rather than the sender's. Agent Handoffs checks each of those with eight tools: eight checks. Your agent sends the handoff records, flows, formats, addresses, failure paths, custody steps, agent lists or delegations 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 handoff material and answers one question about it. The report names the handoff, route, part, step, list, agent or delegation behind every status, so your agent and you can see why it reads the way it does.

`wever_handoff-record-check`

Reads: A system's task handoff records, each with the task, who sent it and who received it, when, where the task stood, the constraints it travels under and when the record was written, beside the task moves seen in other logs.
The signed report states: How many handoffs keep the task, its current state, its constraints and its sender, every record missing one of them, every record written well after the task moved, and every move between agents that nobody wrote down.
Price: 0.10 USDC per call
Verdicts: handoffs_are_rumorsrecord_gapsrecords_unverifiedhandoffs_recorded

`wever_handoff-acceptance-check`

Reads: A handoff flow: each route from sender to receiver with how the receiver confirms it has taken the task, when the sender lets go, how long it waits and whether each acceptance is recorded, with the transfers made on those routes.
The signed report states: Every route where the sender lets go on send or the receiver confirms nothing, every delivery receipt standing in for acceptance, every wait with no limit, and every transfer let go before anyone accepted it.
Price: 0.10 USDC per call
Verdicts: work_can_dropacceptance_gapsacceptance_unverifiedheld_until_accepted

`wever_context-transfer-check`

Reads: A handoff format: each field it carries with the part of the context it holds and whether it is required, plus how the receiving agent fills each part the format leaves out.
The signed report states: Part by part, whether the goal, the current state, the decisions already made, the limits and the open questions travel with the task, or are asked for, reconstructed or assumed by the receiver.
Price: 0.10 USDC per call
Verdicts: receiver_guessestransfer_gapstransfer_unverifiedcontext_travels

`wever_receiver-identity-check`

Reads: A handoff addressing setup: the registered agents with their records and endpoints, and each route with how the sender reaches its receiver, how and when the receiver's identity is checked and what happens on a mismatch.
The signed report states: Every route where any endpoint that answers can receive the task, then every receiver missing from the registry, every address its record does not list, every check that skips the record and every mismatch that only warns.
Price: 0.10 USDC per call
Verdicts: any_endpoint_receivesidentity_gapsidentity_unverifiedreceiver_verified

`wever_handoff-failure-check`

Reads: Each handoff route with where the task goes when the receiver refuses it, fails mid-task or goes quiet, how long quiet lasts before it counts, the fallback and escalation recipient, and when the path was written down.
The signed report states: Whether each refused, failed or silent task returns to its sender, moves to a named fallback or escalates to a named person, with every dropped task, every recipient no one named, every path that only retries and every path written after the first failure.
Price: 0.10 USDC per call
Verdicts: no_road_backfailure_path_gapsfailure_path_unverifiedroad_back_defined

`wever_chain-of-custody-check`

Reads: One task's steps through several agents: each holder with who it came from and went to, when, what that holder changed and whether the step comes from a record, the holder's own report or memory, plus where the task sits now.
The signed report states: Whether the steps link end to end from records, with every broken link, every step resting on memory, every unrecorded change, every interval with no holder and where the task sits now.
Price: 0.10 USDC per call
Verdicts: custody_unreconstructablecustody_gapscustody_unverifiedcustody_traced

`wever_fleet-roster-check`

Reads: The lists of agents an organisation keeps, each with its keeper, whether it is named the roster, how it is kept current and the agents it lists with their owners, beside the agents added, changed or retired.
The signed report states: Whether one roster exists, with every agent known only to a side list, every agent with no owner, a roster with no keeper or update practice, every change the roster missed or took late, and every retired agent still listed.
Price: 0.10 USDC per call
Verdicts: fleet_known_anecdotallyroster_gapsroster_unverifiedsingle_current_roster

`wever_handoff-scope-check`

Reads: A delegation setup: the sender's own access, and each task it hands on with what the task needs and what the receiver gets, how that access reaches it, when it ends and whether it can be passed on.
The signed report states: Every handoff that carries the sender's own credential or whole scope, then every tool, data set and spending amount past what the task needs, every shared credential, every need left out and every grant that outlives the task.
Price: 0.10 USDC per call
Verdicts: sender_access_travelsscope_gapsscope_unverifiedscoped_to_task

Start with the two free tools.

On https://weverlabs.com/mcp-free, anonymous and with no wallet, two Agent Handoffs tools read supplied handoff 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_handoff-snapshot`

Reads: One task's handoff state: the task, its current holder and its state.
Returns: The handoff as one plain record, each part in plain words or not stated.
Access: Free on /mcp-free

`wever_fleet-roster-sample`

Reads: Up to five of an organisation's agent lists, each with whether it is named the roster and its agents with their owners.
Returns: Whether a single roster exists, whether each agent names an owner, and the count. The fleet roster 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_handoff-snapshot at each handoff, so the sender, the receiver and the owner start from one plain record of the task, its holder and its state.
Calls the check that answers the question on https://weverlabs.com/mcp at the moment it matters: when it designs a handoff flow or format, before it hands work to a new agent, when it delegates access, when a handoff is refused or goes quiet, when a task has passed through several agents, and on each review of the organisation's agents.
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 who holds each task, whether it reached the agent you meant, what it carried, where it goes if the receiver refuses, and which agents you run and who owns each.
Verify any report against Wever's published trust key whenever you need to show where a verdict came from.

A worked example

A task let go on send. A delivery receipt read as yes.

The request

{
  "name": "wever_handoff-acceptance-check",
  "arguments": {
    "routes": [
      {
        "name": "planner to booker",
        "from": "planner",
        "to": "booker",
        "acceptance": "delivery_only",
        "sender_releases": "on_send",
        "acceptance_window": "5 minutes",
        "acceptance_recorded": true
      }
    ]
  }
}

What the report returns

Verdict: work_can_drop.

Finding, released on send	The sender on planner to booker lets go of the task as soon as it sends, before the receiver accepts it.
Finding, delivery only	On planner to booker, a delivery receipt from the transport stands for acceptance, so a message delivered to an agent that never takes the task reads as accepted.
Fix, planner to booker	Have the sender on planner to booker keep the task until the receiver accepts it.
Fix, planner to booker	Require an explicit acceptance from the receiving agent on planner to booker, not only a delivery receipt from the transport.

Work can drop between agents with no one holding it: planner to booker.

The planner hands a booking to the booker. It lets go of the task the moment the message is sent, and the only confirmation it waits for is the transport's delivery receipt. A booker that is down, busy or never picks the task up still reads as having it, and the planner has already moved on. The report names both, so the owner has the planner hold the task until the booker explicitly accepts it.

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 Handoffs contract lists the schemas, limits, verdicts and signing details. For job handoff packs, Job Records; for agent registries and escalation, Agent Control; for read-only and enforced access, Agent Access; for limits and breach paths, Agent Limits.

Browse all tools