Agent Coordination · Checks for agents working together

Several agents on one job, working as one.

A group of agents works as one when every task in the plan has an owner, every part of the job sits in one agent’s assignment, every shared record has named writers and a rule for two writes, no two agents commit the same resource or ship contradicting outputs, the joint progress report matches the plan with evidence behind every done claim, every agent that writes or approves is named and identified, a disagreement or stall reaches a named principal or lead on a stated limit, and the report the principal reads states the collisions, unowned tasks, blockers and disagreements behind the work. Agent Coordination checks each of those with eight tools: eight checks. Your agent sends the plan, assignments, shared records, action log, progress report, roster, escalation path or principal report in the call, and each tool returns a signed report that names what is missing, colliding or undisclosed.

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 part of how a group of agents works together and answers one question about it. Every tool reads the recorded coordination material in the call: plans, assignments, state records, action logs, progress reports, rosters and escalation records go in, and a classification comes out. The report names the task, part, record, action, claim, agent, escalation or disclosure behind every status, with the fix for each gap, so your agents and you see why it reads the way it does.

`wever_coordination-plan-check`

Reads: A multi-agent work plan: the agents with their roles, and each task with its owners, the deliverables it produces, the outputs it needs and the tasks it waits for.
The signed report states: Tasks with no owner, deliverables two agents own, circular dependencies and tasks that need an output no task produces, with every deliverable and its owners.
Price: 0.10 USDC per call
Verdicts: plan_unworkableplan_gapsplan_unverifiedplan_workable

`wever_coordination-boundary-check`

Reads: The parts of one job, with any part worked jointly and its lead, and each agent’s assignment as listed parts, excluded parts and the assignment as written.
The signed report states: Parts two agents are told to do, parts in nobody’s assignment and assignments worded so loosely that overlap is inevitable, part by part with the agents covering each.
Price: 0.10 USDC per call
Verdicts: territory_collidesterritory_gapsterritory_unverifiedterritory_clear

`wever_coordination-state-check`

Reads: The shared records a group works from: boards, files, databases and threads, each with its owner, writers, the rule that settles two writes, the history it keeps and where it lives.
The signed report states: Records with no named owner or writer, records several agents overwrite with no conflict rule, and state a joining agent has no way to rebuild.
Price: 0.10 USDC per call
Verdicts: shared_state_unsafeshared_state_gapsshared_state_unverifiedshared_state_sound

`wever_coordination-conflict-check`

Reads: Two or more collaborators’ recorded actions and decisions on the same job, with the resources they commit, the outputs they ship, the reversals they make and the rule that settles a collision.
The signed report states: The same resource committed twice, contradictory outputs shipped and decisions reversed without telling the others, plus whether a resolution rule exists.
Price: 0.10 USDC per call
Verdicts: collaborators_collidecollision_gapscollisions_unverifiedno_collisions

`wever_coordination-progress-check`

Reads: A joint progress report against the plan: each task’s owner, each agent’s claim with its status and evidence, and the blockers with who is clearing them.
The signed report states: Tasks claimed done by two agents, plan tasks nobody claims, blockers with no owner and progress stated with no evidence attached.
Price: 0.10 USDC per call
Verdicts: progress_misreportedprogress_gapsprogress_unverifiedprogress_accounted

`wever_coordination-roster-check`

Reads: The roster of agents on a job: each agent’s name, verifiable identity, role and what it may read, write and approve, with the roles the job needs.
The signed report states: Unnamed or unidentifiable agents holding write or approval rights, roles with no agent in them and one agent holding every approval.
Price: 0.10 USDC per call
Verdicts: rights_unaccountablerights_gapsrights_unverifiedrights_accountable

`wever_coordination-escalation-check`

Reads: How the group handles a disagreement or a stall: where the escalation path is written, its named recipient, what starts it, and the past escalations with how each ended.
The signed report states: Whether disagreements and stalls reach a named principal or lead on a stated limit, with a path that lives only in a prompt and names no recipient read as missing.
Price: 0.10 USDC per call
Verdicts: escalation_missingescalation_gapsescalation_unverifiedescalation_named

`wever_coordination-report-check`

Reads: The group’s report to its principal, with its headline, what it says about collisions, unowned tasks, blockers and unresolved disagreements, and the record behind it.
The signed report states: Whether that friction sits beside the headline with counts that match the record, or is smoothed into a clean summary that calls the work on track.
Price: 0.10 USDC per call
Verdicts: friction_smoothed_overfriction_gapsfriction_unverifiedfriction_disclosed

Start with the two free tools.

On https://weverlabs.com/mcp-free, anonymous and with no wallet, two Agent Coordination tools show what a sound multi-agent work packet holds and what a workable plan looks like beside a flawed one. Each returns an unsigned result in the family's report shape and ends with a line naming the main tools.

`wever_coordination-snapshot`

Reads: A team or job name and a kind of multi-agent work, such as a software build, a research report or event planning.
Returns: The checklist of a sound multi-agent work packet for that work, part by part from the plan to the principal report, with the items the work adds and the check that reads each part.
Access: Free on /mcp-free

`wever_coordination-plan-sample`

Reads: Nothing, or one sample job: a product launch, a research report or a support queue.
Returns: One worked three-agent plan done right beside a flawed one, each piece annotated with why it passes or fails, read by the plan, state and escalation checks. The plan check reads your own.
Access: Free on /mcp-free

How agents and people use it.

Your agents

Pull the packet checklist with wever_coordination-snapshot before the work starts, so the plan, the boundaries, the shared records, the roster and the escalation path are in place from the first task.
Call the check that answers the question on https://weverlabs.com/mcp at the moment it matters: when the plan is set, when a new agent joins, after a burst of commitments, before a progress report goes out and before the group reports to its principal.
Act on the verdict and keep the signed report beside the records it covers, so every split, collision and escalation carries the check behind it.

You

See each collision, unowned task and stalled disagreement named with the change that closes it.
Hear about a double booking or a reversed decision from the record, while there is still time to act on it.
Read a report that tells you where the work collided, stalled or split, and verify any check against Wever's published trust key whenever you need to show where a verdict came from.

A worked example

Three agents, one demo room booked twice, two launch dates shipped.

The request

{
  "name": "wever_coordination-conflict-check",
  "arguments": {
    "agents": [
      "scheduler",
      "sales",
      "support"
    ],
    "actions": [
      {
        "id": "a1",
        "agent": "scheduler",
        "kind": "commit",
        "resource": "demo room, Nov 20 3 PM"
      },
      {
        "id": "a2",
        "agent": "sales",
        "kind": "commit",
        "resource": "demo room, Nov 20 3 PM"
      },
      {
        "id": "o1",
        "agent": "sales",
        "kind": "output",
        "subject": "launch date",
        "value": "Nov 20",
        "shipped": true
      },
      {
        "id": "o2",
        "agent": "support",
        "kind": "output",
        "subject": "launch date",
        "value": "Nov 27",
        "shipped": true
      }
    ],
    "rule": {
      "resolution": "lead_decides",
      "decider": "scheduler"
    }
  }
}

What the report returns

Verdict: collaborators_collide.

Finding, resource double committed	1 resource is committed twice: demo room, Nov 20 3 PM (a1 and a2 by scheduler and sales).
Finding, outputs contradict	1 pair of shipped outputs contradicts each other: launch date (Nov 20 against Nov 27, o1 and o2).
Fix, resource double committed	Release or withdraw one of every pair of commitments on the same resource, and have agents claim a resource on the shared record before committing it.
Fix, outputs contradict	Settle every contradiction before an output ships: one agent owns each subject, and a shipped output that contradicts another is corrected with the principal told.

Collaborators have collided on the job: resource double committed and outputs contradict.

The scheduler and the sales agent each committed the demo room for 3 PM on November 20, so two customers hold the same slot. The sales agent then told a customer the launch is on November 20 while the support agent told another it is November 27. The group has a rule, the scheduler decides, so the collisions have a way to close: the scheduler releases one booking, settles the launch date and has the agent that shipped the wrong one correct it with the principal told.

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 Coordination contract lists the schemas, limits, verdicts and signing details. For one handoff record between two parties, Agent Handoffs; for one principal delegating to one agent, Agent Delegation; for parties with opposing interests, Agent Negotiation; for tracing a single run, Agent Observability.

Browse all tools