# MCPFax Agent Continuity (remote · mcpfax-continuity.bowling-anthony.workers.dev)

Locks, work queues and barriers for multi-agent work. Never reads your code, files or transcripts.

- Trust score: 58/100 (low)
- Change this week: +4
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-22

## Components

- remote · `mcpfax-continuity.bowling-anthony.workers.dev`: 58/100 (this document), [markdown](https://verifymcp.io/servers/com-mcpscores-agent-continuity/mcpfax-continuity.md), [page](https://verifymcp.io/servers/com-mcpscores-agent-continuity/mcpfax-continuity)

## Channel facts

- Endpoint: `https://mcpfax-continuity.bowling-anthony.workers.dev/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.1.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-22.

- **Endpoint Security**: 46/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation check failed: no authorisation is required to call this server, and it exposes a tool marked destructive (lease_release).
  - HTTPS enforcement could not be verified: the plaintext port answered with HTTP 405, which proves neither a plaintext path nor enforcement.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 63/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 13043 tokens (~395/item across 33 items; 33 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 27/100
  - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Capabilities**: 60/100
  - Spec-recency check failed: implements MCP spec 2025-06-18; the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add --transport http com-mcpscores-agent-continuity https://mcpfax-continuity.bowling-anthony.workers.dev/mcp
```

### Codex

```toml
[mcp_servers.com-mcpscores-agent-continuity]
url = "https://mcpfax-continuity.bowling-anthony.workers.dev/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "com-mcpscores-agent-continuity": {
      "type": "remote",
      "url": "https://mcpfax-continuity.bowling-anthony.workers.dev/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add com-mcpscores-agent-continuity --url https://mcpfax-continuity.bowling-anthony.workers.dev/mcp --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  com-mcpscores-agent-continuity:
    url: "https://mcpfax-continuity.bowling-anthony.workers.dev/mcp"
```

### Other

```json
{
  "mcpServers": {
    "com-mcpscores-agent-continuity": {
      "type": "http",
      "url": "https://mcpfax-continuity.bowling-anthony.workers.dev/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-22 (score 58, +1)

No change was recorded against any check on this day. Stability & Change Management went from 23 to 27. That category is still filling its 30-day observation window: 7 days of observed history at the previous scan, 8 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-08-19 (score 57, +1)

- [security] The server rewrote its instructions, which are the text every model session reads

### 2026-08-17 (score 56, +1)

No change was recorded against any check on this day. Stability & Change Management went from 7 to 10. That category is still filling its 30-day observation window: 2 days of observed history at the previous scan, 3 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-08-16 (score 55, +1)

No change was recorded against any check on this day. Stability & Change Management went from 3 to 7. That category is still filling its 30-day observation window: 1 days of observed history at the previous scan, 2 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-08-15 (score 54, 0)

- [functional improvement] Stability: unverified → 0.03
- [functional] Server version: 1.0.1 → 1.1.0
- [functional] Server version: 1.0.0 → 1.0.1

### 2026-08-14 (score 54)

First indexed and scored.

## MCP tools (33)

### `register` (~232 tokens)

Register an agent namespace and mailbox

Create a durable identity for an agent. Returns an agent_secret (the only credential; store it in the agent's configuration the way you would an API key — an amnesiac agent cannot remember it for you), the public agent address other agents mail work to, and the namespace id. FREE. The secret is never stored here: the namespace id is its salted SHA-256 digest, so a dump of our storage cannot reveal it, and we cannot recover it for you if you lose it. FREE — this tool never charges. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/register.

Input parameters:

- `agent_id` (string): A label you choose and own, <=64 chars. Never derive it from a provider's session/thread/run id — that would bind your continuation to the platform that issued it. Alias: label. Example: 'pricing-age…
- `agent_secret` (string): Optional: bring your own secret (>=32 chars) derived from your own secret manager. Omit to have one generated.

### `whoami` (~153 tokens)

Your address and mailbox counts

Report this namespace's public address, registration time, and mailbox counts: how many items exist, how many are due right now, when the next one falls due, and how many are dead-lettered. FREE, deliberately: knowing THAT work exists must never cost money — only the envelope itself is billable. Poll this for free, then pay only when there is something to collect. FREE — this tool never charges. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/whoami.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.

### `claim` (~342 tokens)

Idempotency claim

Exactly-once guard for work that costs money or has side effects. The first call for a key returns granted:true and is FREE. Every later call for that key returns granted:false with first_claimed_at and, if complete() was called, the stored result — so a retrying agent gets the answer instead of paying for the same paid API call twice. $0.002 is charged the FIRST time a key is denied (and again only if complete() has since attached a new result); repeated denials of the same unchanged fact are free. If we cannot determine the state we return granted:null and you must NOT proceed. Costs $0.002 USDC per call via x402 on Base, and ONLY when granted === false, and this exact denial has not been billed before; otherwise the same call returns the full answer and settles nothing. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/claim.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `key` (string, required): Your idempotency key. Scoped to your namespace; hashed before storage. <=256 chars. Example: 'charge-order-8814'.
- `scope` (string): Optional unit of work this belongs to. Recording it lets resume_packet tell a later invocation you already made this claim. Example: 'permit-review-2026-08'.
- `ttl_seconds` (integer): How long the claim is remembered. Default 86400, max 2592000. Example: '86400'.

### `complete` (~275 tokens)

Attach a result to a claim

Attach the outcome to an idempotency CLAIM you hold — NOT for finishing a mailbox task (use inbox_ack) or a queue item (use work_done). A later duplicate attempt then receives your stored result from claim() instead of redoing the work. FREE — this is a write, and we never bill for storing. If the claim has expired or you never held one, we REFUSE with recorded:false, reason 'no_active_claim' rather than storing a result nothing will ever read; re-claim the key first. The result is an opaque blob: we never parse, index or log it. FREE — this tool never charges. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/complete.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `key` (string, required): The same key you claimed. Example: 'charge-order-8814'.
- `result` (object, required): Opaque result blob, <=32768 bytes serialized. Example: '{"tx":"0x.."}'.
- `status` (string): Optional: 'ok' or 'failed'. Default 'ok'. Recorded verbatim, not interpreted. Example: 'ok'.

### `lease` (~884 tokens)

Acquire a mutual-exclusion lease

Mutual exclusion so two instances of the same agent do not both process one item. Returns acquired:true with a fence token (FREE), or acquired:false naming the current holder and when the lease expires. ACQUIRED:FALSE MEANS YOU DO NOT HOLD THE LOCK — you must NOT proceed, and must not treat the refusal as advisory: stop work on that resource, wait retry_after_seconds, or do something else. acquired:null means we could not determine the state, which is also not permission to proceed. YOU ARE GIVEN TWO NUMBERS AND THEY DO DIFFERENT JOBS. `fence` is a CREDENTIAL: a large integer drawn fresh and independently for every acquisition, so it is never 1, never a step from the fence you held last time, and not computable from any number of fences you have ever been given. Treat it as a secret — it is the one thing that tells you apart from another instance using your holder label. `generation` is the ORDER: a counter that strictly increases on every fresh acquisition and never resets, not on expiry and not on release. It is not a secret, it is the number to compare and the number to hand to an external store that must reject stale writers. A revived holder from an earlier generation therefore cannot renew or release a lease someone else now holds — not because its number is smaller, but because it does not have the new one. RE-ACQUIRING A LEASE YOU HOLD IS A RENEWAL ONLY IF YOU PRESENT ITS `fence` — a holder LABEL is not proof, because two instances of the same agent are exactly the callers most likely to share one, and we will not hand the same lock to both. A live lease requested under its own label without the fence is REFUSED with acquired:false, same_holder_label:true and held_by, never silently renewed. A renewal keeps your fence and stays free. $0.002 is charged the first time you are refused by a given holder; being refused again by the SAME holder is free. Costs $0.002 USDC per call via x402 on Base, and ONLY when acquired === false, and this refusal by this holder…

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `fence` (integer): Optional: the fence token you were given for this key. Supply it to RENEW the lease you already hold. Omit it and a live lease is refused rather than renewed, because a holder label alone cannot tell…
- `holder` (string, required): Who is asking — an instance id you choose. Required, and it MUST BE UNIQUE PER LIVE INSTANCE: two concurrently running copies that send the same holder are two different callers, and only one of them…
- `key` (string, required): Resource being locked. Namespace-scoped, hashed before storage. Example: 'queue/orders'.
- `scope` (string): Optional unit of work, so resume_packet can report the leases you still hold. IT IS ALSO WHAT MAKES THIS LEASE RECOVERABLE: a dead-man switch releases only leases recorded against a scope, so a lease…
- `ttl_seconds` (integer): Lease lifetime. Default 60, max 3600. Example: '60'.

### `lease_renew` (~316 tokens)

Extend a lease you hold

Extend a lease you still hold, using the fence token you were given. FREE. Fails (renewed:false) if the lease expired or was taken by someone else — treat that as having lost the lock and stop work. A renewal keeps both of your numbers: the same fence and the same generation, because it is the same acquisition. A successful renewal also corrects the scope ledger, so resume_packet and the dead-man switch see the real new expiry rather than the one recorded when you first acquired it. FREE — this tool never charges. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/lease/renew.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `fence` (integer, required): The fence token from lease(). Required, and only the caller lease() handed it to has it — it is drawn independently for each acquisition, so it cannot be derived from an earlier one and the example b…
- `holder` (string, required): The same holder id you acquired with. Example: 'worker-3-6f2a91'.
- `key` (string, required): The leased key. Example: 'queue/orders'.
- `ttl_seconds` (integer): New lifetime from now. Default 60, max 3600. Example: '60'.

### `lease_release` (~326 tokens)

Release a lease

Release a lease you hold so the next worker can take it immediately instead of waiting for the TTL. FREE. If you no longer hold it we REFUSE rather than free someone else's lock: a stale fence returns released:false, reason 'not_holder', naming the current holder — treat that as having lost the lock and stop work. An already-expired lease returns released:false, reason 'expired'. Neither is an error you can retry away; both mean the lock is not yours. A successful release also corrects the scope ledger, so resume_packet stops briefing a later agent that it still holds a lock it gave back. FREE — this tool never charges. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/lease/release.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `fence` (integer, required): The fence token from lease(). Required, and checked exactly: a stale one is refused, never honoured. Each acquisition's token is an independent draw, so the one you were given for an earlier generati…
- `holder` (string, required): The holder id that owns the lease. Example: 'worker-3-6f2a91'.
- `key` (string, required): The leased key. Example: 'queue/orders'.

### `resume_packet` (~383 tokens)

Resume the work, not the conversation

THE HEADLINE TOOL. Returns a briefing, not an archive: objective, last verified state, what arrived while you were gone, the single next action, files, risks, open questions, tools already used and budget remaining. Composed from your last checkpoint PLUS server-observed facts we hold ourselves — the claims you made, the leases you still hold, the watermarks you set, the mail that arrived since — so the packet is not limited to what an earlier session remembered to write down. Provider-neutral plain JSON: a checkpoint written by one model under one framework is resumable by any other. $0.002 only when there is a real packet to return AND that briefing has changed since you last paid for it — recomposing the same briefing is free. An empty scope tells you so and costs nothing. Costs $0.002 USDC per call via x402 on Base, and ONLY when the packet carries something — a checkpoint, new events since it, or server-observed facts — and this exact briefing has not been billed before; otherwise the same call returns the full answer and settles nothing. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/resume.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `box` (string): Sub-mailbox to count new events from, default 'inbox'. Example: 'inbox'.
- `max_events` (integer): How many new-event headers to include, 1..50. Default 25. Example: '25'.
- `scope` (string, required): The unit of work to resume — a workflow, project or task id you choose. Namespace-scoped. Example: 'permit-review-2026-08'.

### `checkpoint_put` (~957 tokens)

Checkpoint the work

Save where the work got to, in a STRUCTURED shape so the next invocation can actually act on it. FREE. `objective` and `next_action` are REQUIRED and a checkpoint without them is refused — a vague checkpoint produces a vague briefing, so the schema is the guardrail. Work state is small: aim for a few kilobytes, not a transcript. The ENVELOPE (objective, next_action, status, files, risks and the rest) is cleartext and is what resume_packet synthesizes from. The BODY (`body`, `state`, `provider_extras`) is opaque — never parsed, indexed or logged in any mode. Set privacy_mode:'client_key' and encrypt the body yourself if it is sensitive; we then cannot read it and never hold your key. FREE — this tool never charges. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/checkpoint/put.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `artifacts` (array): ENVELOPE. Artifact references produced so far (ids, URLs). Example: '[]'.
- `body` (string): BODY, OPAQUE. Full context, reasoning, file contents — anything sensitive. Never parsed, indexed or logged in any mode. Send ciphertext here with privacy_mode:'client_key'.
- `budget_remaining` (object): ENVELOPE. Whatever budget means for you — calls, tokens, USDC. Example: '{"usdc":"0.05"}'.
- `dependencies` (array): ENVELOPE. What this work depends on. Example: '[]'.
- `due_by` (string): ENVELOPE. ISO-8601 deadline for the work, if it has one. Example: '2026-08-20T00:00:00Z'.
- `evidence` (array): ENVELOPE. References supporting the verified state. Example: '[]'.
- `files` (array): ENVELOPE. File references or paths — references, not contents. Contents go in `body`. Example: '[]'.
- `next_action` (string, required): ENVELOPE. REQUIRED. The single next step, concretely. Alias: next_step. <=2048 chars. Example: 'Call the pricing API for SKU-88 and compare to quote'.
- `objective` (string, required): ENVELOPE. REQUIRED. The goal, as currently stated. <=2048 chars. Example: 'Decide whether permit P-1 is a sales opportunity'.
- `open_questions` (array): ENVELOPE. Unresolved questions blocking or shaping the work. Example: '[]'.
- `priority` (integer): ENVELOPE. 0 (highest) to 9. Example: '5'.
- `privacy_mode` (string): 'none' (default; body stored as given, still never introspected) or 'client_key' (you encrypted it; we cannot read it and never hold your key). 'escrow' is reserved and not enabled. Example: 'none'.
- `provider_extras` (object): BODY, OPAQUE. Vendor/framework-specific state. Stored and returned verbatim, never interpreted. Example: '{}'.
- `remaining` (array): ENVELOPE. What still has to be done. Example: '["price it","draft the email"]'.
- `risks` (array): ENVELOPE. Known risks. Example: '[]'.
- `scope` (string, required): The unit of work. Alias: workflow_id. Namespace-scoped. Example: 'permit-review-2026-08'.
- `state` (object): BODY, OPAQUE. Free-form resume state, never parsed. Example: '{"cursor":"abc"}'.
- `status` (string): ENVELOPE. Where the work stands, e.g. in_progress / blocked / waiting / done. Your vocabulary; we do not interpret it. Example: 'in_progress'.
- `step` (string): ENVELOPE. Optional short step label. Example: 'step-3'.
- `tools_used` (array): ENVELOPE. Tools already called, so the next invocation does not redo the work. Example: '[]'.
- `ttl_seconds` (integer): Retention. Default 2592000 (30d), max 7776000 (90d). Example: '2592000'.
- `verified_state` (object): ENVELOPE. A SHORT summary of what was actually CONFIRMED (not assumed). Put the detail in `body`. Example: '{"permit_fetched":true}'.

### `checkpoint_get` (~222 tokens)

Read the raw checkpoint

Fetch the last checkpoint verbatim — what was stored, with no briefing composed around it. Most callers want resume_packet instead, which folds in what arrived while you were gone and what we observed you doing. $0.002 ONLY when a checkpoint exists AND its version has changed since you last paid for it — re-reading an unchanged checkpoint is free. If there is none we say so and charge nothing. Costs $0.002 USDC per call via x402 on Base, and ONLY when found === true, and this exact checkpoint version has not been billed before; otherwise the same call returns the full answer and settles nothing. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/checkpoint/get.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `scope` (string, required): The unit of work. Alias: workflow_id. Example: 'permit-review-2026-08'.

### `watermark_set` (~241 tokens)

Record how far you read

Record how far you got through a stream, feed or table so the next invocation knows where to start. FREE. The position is an opaque string we store verbatim and never interpret. FREE — this tool never charges. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/watermark/set.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `position` (string, required): Opaque cursor/offset/timestamp, <=1024 chars. Example: '2026-08-12T09:00:00Z'.
- `scope` (string): Optional unit of work, so resume_packet can report where you had read to. Example: 'permit-review-2026-08'.
- `stream` (string, required): Stream identifier. Namespace-scoped, hashed before storage. Example: 'orders-feed'.
- `ttl_seconds` (integer): Retention. Default 7776000 (90d), max 31536000 (365d). Example: '7776000'.

### `watermark_get` (~194 tokens)

What is new since I last looked

Fetch the position you last recorded for a stream, so you can ask an upstream only for what is new. $0.002 ONLY when a watermark exists AND its position has moved since you last paid for it — re-reading an unchanged position is free. Never set one? Then we tell you so and charge nothing. Costs $0.002 USDC per call via x402 on Base, and ONLY when found === true, and this exact position has not been billed before; otherwise the same call returns the full answer and settles nothing. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/watermark/get.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `stream` (string, required): The stream identifier. Example: 'orders-feed'.

### `seen_add` (~276 tokens)

Remember items you processed

Record items you have already processed. FREE. Items are stored ONLY as salted SHA-256 digests — we can test membership but cannot read, list or reconstruct what you deduped. A set holds up to 10000 entries; when full, adds are refused (never silently forgotten) and you should rotate to a new set name. FREE — this tool never charges. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/seen/add.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `items` (array, required): Up to 100 strings per call, each <=1024 chars. Example: '["id-1","id-2"]'.
- `scope` (string): Optional unit of work, so resume_packet can report which sets you are deduping against. Example: 'permit-review-2026-08'.
- `set` (string, required): Set name. Namespace-scoped, hashed before storage. Example: 'processed-ids'.
- `ttl_seconds` (integer): Sliding set lifetime, refreshed on each add. Default 2592000 (30d), max 31536000. Example: '2592000'.

### `seen_check` (~255 tokens)

Which of these are new

Given a batch of items, return only the ones not already in the set — the work you actually still have to do. $0.002 ONLY when we filter at least one item out, because that is the call where we saved you work, AND only when that answer has changed since you last paid for it — asking the same question again while the set has not grown is free. If every item is new we tell you so and charge nothing. Costs $0.002 USDC per call via x402 on Base, and ONLY when filtered_count >= 1, and this exact set of already-seen items has not been billed before; otherwise the same call returns the full answer and settles nothing. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/seen/check.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `items` (array, required): Up to 100 strings per call. Example: '["id-1","id-9"]'.
- `set` (string, required): The set name. Example: 'processed-ids'.

### `retry_state` (~374 tokens)

Attempt count and backoff that survives a crash

Durable retry bookkeeping, so backoff survives the session that died. Returns the attempt count, first and last attempt times, and a deterministic suggested backoff. Pass record:true to count this attempt. $0.002 ONLY when we return remembered history from an earlier session (attempts>0 before this call), and only when that attempt count has changed since you last paid for it. The very first call for a key tells you nothing you did not know, so it is free. NOTE that record:true is a WRITE: it counts a new attempt, so it produces a genuinely new answer and is billable again. Use the default record:false to read the history without changing it. Costs $0.002 USDC per call via x402 on Base, and ONLY when attempts_before_call >= 1 (remembered history from an earlier session), and this exact attempt count has not been billed before; otherwise the same call returns the full answer and settles nothing. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/retry-state.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `key` (string, required): What is being retried. Namespace-scoped, hashed before storage. Example: 'sync-vendor-7'.
- `record` (boolean): Count this attempt before answering. Default false. Example: 'true'.
- `scope` (string): Optional unit of work, so resume_packet can report what is being retried. Example: 'permit-review-2026-08'.
- `ttl_seconds` (integer): Retention. Default 604800 (7d), max 2592000. Example: '604800'.

### `send` (~675 tokens)

Mail a task envelope to an agent

Agent-to-agent mail. Queue a rich task envelope addressed to any registered agent so it finds the work waiting whenever it next starts. Nobody waits and nobody polls. FREE. You may SEND to an address but never READ another agent's mailbox — reading requires that agent's secret. The envelope carries objective, context, attachments and history so the receiving invocation can start work without rebuilding state it no longer has. A mailbox holds 1000 pending items, of which ordinary mail may occupy 968; the last 32 are reserved for the recipient's OWN dead-man alerts and barrier notifications, so filling someone's mailbox can never silence their safety notifications. FREE — this tool never charges. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/mail/send.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `attachments` (array): Opaque refs or blobs. Example: '[]'.
- `context` (object): Opaque payload the receiver needs. Never parsed or logged. Example: '{"permit_id":"P-1"}'.
- `dedupe_key` (string): Optional. A second send with the same dedupe_key to the same mailbox is refused as a duplicate. Example: 'permit-P-1'.
- `due_at` (string): ISO-8601 time it becomes visible. Default: immediately. Example: '2026-08-13T09:00:00Z'.
- `every_seconds` (integer): Optional repeat interval (>=60). A new occurrence is queued when this one is acked. Example: '86400'.
- `history` (array): Prior reasoning or tool output from earlier episodes. Example: '[]'.
- `in_seconds` (integer): Alternative to due_at: become visible this many seconds from now. Example: '3600'.
- `max_deliveries` (integer): Attempts before dead-lettering. Default 5, max 50. Example: '5'.
- `objective` (string, required): What the receiving agent should achieve, <=2048 chars. Example: 'Determine if this creates a sales opportunity'.
- `priority` (integer): 0 (highest) to 9. Default 5. Among the items that are DUE, delivery order is priority first, then oldest due time. So a stream of higher-priority items can delay a lower-priority one indefinitely — t…
- `provider_extras` (object): Vendor/framework-specific state. Carried verbatim, never interpreted. Example: '{}'.
- `repeat_count` (integer): How many further occurrences to queue. Default 0, max 1000. Example: '7'.
- `scope` (string): Optional unit of work this task belongs to, so the recipient's resume_packet groups it. Example: 'permit-review-2026-08'.
- `to` (string, required): Destination address, 'agent:<id>' or 'agent:<id>/<box>'. Must be registered. Example: 'agent:7k2p.../pricing'.

### `inbox_schedule` (~492 tokens)

Leave a note for your future self

Leave work for your own next invocation — the same as send() addressed to yourself. FREE. No callback URL is required or accepted: agents are not web services and mostly have no endpoint, so the model is a future inbox, not a webhook. Whenever your next invocation starts, inbox_poll finds this waiting. FREE — this tool never charges. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/inbox/schedule.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `attachments` (array): Opaque refs or blobs. Example: '[]'.
- `box` (string): Sub-mailbox name, default 'inbox'. Example: 'inbox'.
- `context` (object): Opaque payload. Never parsed or logged. Example: '{"permit_id":"P-1"}'.
- `dedupe_key` (string): Optional duplicate suppression key. Example: 'permit-P-1'.
- `due_at` (string): ISO-8601 due time. Example: '2026-08-13T09:00:00Z'.
- `every_seconds` (integer): Optional repeat interval (>=60). Example: '86400'.
- `history` (array): Prior reasoning or tool output. Example: '[]'.
- `in_seconds` (integer): Alternative to due_at: seconds from now. Example: '3600'.
- `max_deliveries` (integer): Attempts before dead-lettering. Default 5, max 50. Example: '5'.
- `objective` (string, required): What future-you should achieve, <=2048 chars. Example: 'Re-check the permit status'.
- `priority` (integer): 0 (highest) to 9. Default 5. Among DUE items, delivery order is priority first, then oldest due time. Example: '5'.
- `provider_extras` (object): Vendor/framework-specific state. Carried verbatim, never interpreted. Example: '{}'.
- `repeat_count` (integer): Further occurrences to queue. Default 0, max 1000. Example: '7'.
- `scope` (string): Optional unit of work this task belongs to, so resume_packet groups it. Example: 'permit-review-2026-08'.

### `inbox_poll` (~254 tokens)

What is due for me

Collect the next due task envelope from your mailbox. One envelope per call. The item is claimed with a visibility timeout: ack it when done, or it returns to the queue for another attempt, so work is never lost if this invocation dies. $0.002 charged the FIRST time a given task_id is delivered; every redelivery of that same task is FREE. Nothing due? We say so and charge nothing. Costs $0.002 USDC per call via x402 on Base, and ONLY when an envelope was delivered for the first time (redelivery is free); otherwise the same call returns the full answer and settles nothing. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/inbox/poll.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `box` (string): Sub-mailbox to read, default 'inbox'. Example: 'inbox'.
- `visibility_timeout_seconds` (integer): How long the item stays claimed. Default 300, min 5, max 86400. Example: '300'.

### `inbox_ack` (~307 tokens)

Mark a task done

Acknowledge a task you finished. FREE and idempotent — acking twice is not an error. If the task was a repeating schedule, the next occurrence is queued now. An optional opaque result is stored on the tombstone so a later duplicate can see what happened. If your visibility timeout already lapsed and the envelope was redelivered, the ack still succeeds and removes it — this queue has no fence token, so ack cannot tell your late ack from the current holder's. Ack promptly, or raise visibility_timeout_seconds on inbox_poll; if you need refuse-on-lost-ownership, that is work_take/work_done, which is fenced. An unknown task_id returns acked:false, reason 'unknown_task' — it may have been dead-lettered, or its tombstone may have expired. FREE — this tool never charges. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/inbox/ack.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `result` (object): Optional opaque outcome blob. Example: '{"ok":true}'.
- `status` (string): 'done' or 'failed'. Default 'done'. Recorded, not interpreted. Example: 'done'.
- `task_id` (string, required): The task_id from inbox_poll. Example: 'tsk_...'.

### `inbox_nack` (~168 tokens)

Give a task back

Explicitly return a claimed task to the queue instead of waiting for its visibility timeout, optionally deferring it. FREE. Redelivery of the same task_id is always free, so handing work back costs nothing. FREE — this tool never charges. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/inbox/nack.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `delay_seconds` (integer): Defer this many seconds before it is visible again. Default 0. Example: '600'.
- `task_id` (string, required): The task_id from inbox_poll. Example: 'tsk_...'.

### `heartbeat` (~560 tokens)

Dead-man switch

AN AGENT CANNOT DETECT ITS OWN DEATH — from the inside, 'I stopped' and 'I am about to do the next step' are the same thing. Only something outside the process can tell them apart. Each call records a beat and arms a durable alarm for expect_within_seconds. Beat again in time and the alarm simply re-arms. Miss it and the expiry actions run EXACTLY ONCE: release_leases (the same release path a live agent uses), queue_alert (one envelope into a mailbox address you nominate), mark_failed (so resume_packet reports the death as an OBSERVED fact, not a self-report). FREE — it is a write. The alert is billed only when it is collected, by the existing inbox_poll first-delivery rule; there is no second charge. FREE — this tool never charges. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/heartbeat.

Input parameters:

- `agent_id` (string): Optional label for the beating instance, carried in the alert so a human can tell which worker died. <=64 chars. Example: 'worker-3'.
- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `disarm` (boolean): Stop the switch instead of beating. Use this when the work finishes, or a completed job raises a false alarm. Default false. Example: 'false'.
- `expect_within_seconds` (integer, required): Beat again within this many seconds or the switch fires. Min 2, max 2592000 (30 days). Example: '300'.
- `notify_address` (string): REQUIRED with 'queue_alert'. A registered address, 'agent:<id>' or 'agent:<id>/<box>'. WRITE-ONLY: we queue an envelope into it and never read it, exactly like send(). Example: 'agent:7k2p.../alerts'.
- `on_expiry` (array): Which actions run if the next beat is late: any of 'release_leases', 'queue_alert', 'mark_failed'. Default ['mark_failed']. They always run in the order release_leases, mark_failed, queue_alert so th…
- `scope` (string, required): The unit of work whose liveness this tracks. Namespace-scoped, and the scope resume_packet will report the death against. Example: 'permit-review-2026-08'.

### `budget_record` (~401 tokens)

Record a spend against a unit of work

An agent cannot see its own spend across sessions, so runaway cost is invisible until the bill arrives. Append one amount to this scope's ledger. FREE and APPEND-ONLY — nothing is overwritten and nothing is silently dropped; when the ledger is full, adds are REFUSED. The amount is an OPAQUE DECIMAL STRING stored byte-exact as you send it: we never convert a currency, never assume six decimals and never touch a float. Totals are summed as exact integers at the widest scale you actually used. FREE — this tool never charges. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/budget/record.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `amount_usdc` (string, required): A decimal string, e.g. '0.002' or '1.25'. Stored EXACTLY as given and returned byte-identical. Optionally negative for a refund. Never converted or rescaled. Example: '0.002'.
- `label` (string): What the money went on, so budget_check can break the total down. <=64 chars, stored in plain text. Example: 'resume_packet'.
- `limit` (string): Optional. Set or update this scope's limit, as a decimal string. We only ever REPORT against it — we never block a call, because enforcement is your decision and not our authority. Example: '1.00'.
- `scope` (string, required): The unit of work this spend belongs to. Namespace-scoped, and the same scope resume_packet reports against. Example: 'permit-review-2026-08'.
- `ttl_seconds` (integer): Ledger retention. Default 2592000 (30d), max 7776000 (90d). Example: '2592000'.

### `budget_check` (~330 tokens)

What has this work cost me

What this unit of work has actually cost across every session, with a per-label breakdown and a lifetime total. If a limit is set (or you pass one here) we report over_limit — WE REPORT, WE NEVER BLOCK: enforcement is the caller's decision and we will not pretend to an authority we do not have. Amounts come back byte-exact in the units you supplied. $0.002 ONLY when there is recorded history in the window; an empty ledger tells you so and costs nothing, and asking again for an unchanged total is free. Costs $0.002 USDC per call via x402 on Base, and ONLY when count >= 1 in the requested window, and this exact total has not been billed before; otherwise the same call returns the full answer and settles nothing. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/budget/check.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `limit` (string): Optional. Compare against this limit for this call only, instead of the one stored on the scope. Example: '1.00'.
- `scope` (string, required): The unit of work. Example: 'permit-review-2026-08'.
- `window_seconds` (integer): How far back to total. Default 86400 (1 day), max 31536000 (365 days). The lifetime total is always reported alongside it. Example: '86400'.

### `barrier_create` (~669 tokens)

Open a join point for fan-out work

Fan work out to N agents and have the LAST one to finish wake the joiner. FREE. A BARRIER THAT WAITS FOR ALL N IS A HANG WAITING TO HAPPEN, so stragglers are the normal case here, not an edge case: set min_count and/or deadline_seconds and we fire on whichever comes first, ALWAYS naming the participants that did not report. Exactly ONE envelope is queued to notify_address, carrying every participant's payload; that delivery is billed by the existing inbox_poll rule, so there is no new charge. If nothing has fired by the TTL we queue a `barrier_timeout` envelope naming the missing participants — a timeout is information and is delivered, never silently dropped. REUSING A BARRIER_ID IS THE NORMAL PATTERN: while a join is still open this call is idempotent and refuses to reset it (created:false), because a retrying agent must not be able to reset a join others are signalling — but once it has fired or timed out, calling barrier_create with the same id opens a NEW GENERATION with your new roster, and that generation gets its own notification. FREE — this tool never charges. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/barrier/create.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `barrier_id` (string, required): Your name for this join point. Namespace-scoped; stored in plain text so a timeout can name it back to you. Example: 'quarterly-rollup-2026q3'.
- `deadline_seconds` (integer): Fire at this many seconds from now with whoever has signalled, whether or not min_count was reached. Must be <= ttl_seconds. The notification names who did not report. Example: '600'.
- `expected_count` (integer): How many participants you expect. 1..500. Defaults to the length of `participants` when you supply a roster. Example: '3'.
- `min_count` (integer): Fire as soon as THIS many have signalled, instead of waiting for all of them. Default: expected_count. Set it lower and a straggler cannot hang the join. Example: '2'.
- `notify_address` (string, required): Where the completion, deadline or timeout envelope goes. Must be registered. WRITE-ONLY: we queue into it and never read it. Example: 'agent:7k2p.../joins'.
- `objective` (string): Optional text carried into every envelope so the joiner knows what it is being woken for. <=2048 chars. Example: 'Roll up the three regional reports'.
- `participants` (array): Optional roster of participant ids. Supply it and every notification names exactly who is missing; omit it and we can only report the shortfall. A signal from outside the roster is recorded but does…
- `ttl_seconds` (integer): How long the barrier lives before timing out. Default 3600, min 5, max 2592000. Example: '3600'.

### `barrier_signal` (~339 tokens)

Signal that your part is done

Report that one participant finished, optionally attaching a payload the joiner will receive. FREE and IDEMPOTENT PER PARTICIPANT — the same participant_id signalling twice counts once and never double-fires the join. The barrier is a single Durable Object, so N simultaneous signals produce exactly one notification. A signal to a join that ALREADY FIRED on min_count is still recorded and reported in barrier_status, but it cannot fire a second notification — the joiner was already told, and was told exactly who was missing. A signal to a join that has TIMED OUT or passed its TTL is REFUSED with signalled:false, reason 'expired': your payload did NOT reach the joiner, so do not assume it did. That barrier_id is not locked — call barrier_create with it to open a new generation of the join. FREE — this tool never charges. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/barrier/signal.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `barrier_id` (string, required): The barrier to signal. Example: 'quarterly-rollup-2026q3'.
- `participant_id` (string, required): Who is signalling. <=128 chars, stored in plain text so a timeout can name who is missing. Example: 'region-north'.
- `payload` (object): Optional opaque result for the joiner, <=8192 bytes. Never parsed, indexed or logged. Example: '{"rows":128}'.

### `barrier_status` (~225 tokens)

How far along is the join

Progress on a join point: how many of the expected participants have signalled, which ones, who is still outstanding, and whether the completion or timeout envelope has been queued. $0.002 ONLY when there is real progress to report (at least one signal) AND the answer has changed since you last paid for it — an untouched barrier, or a repeat of an answer you already bought, costs nothing and says so. Costs $0.002 USDC per call via x402 on Base, and ONLY when signals >= 1, and this exact progress state has not been billed before; otherwise the same call returns the full answer and settles nothing. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/barrier/status.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `barrier_id` (string, required): The barrier to inspect. Example: 'quarterly-rollup-2026q3'.

### `work_push` (~433 tokens)

Push work items onto a durable queue

THE ALTERNATIVE TO THIS IS WRITING DISTRIBUTED WORK-DISTRIBUTION CODE YOURSELF — assignment, collision avoidance, lease expiry, retry, dead-worker recovery, straggler policy. Push 100 items in one go and exit, and keep pushing until the queue holds your whole batch; workers pull independently, with no assignment logic, no coordinator and nothing staying alive. FREE, and IDEMPOTENT PER item_id: pushing the same item_id twice adds it once, so a retrying parent cannot duplicate the fan-out. Payloads are opaque and never parsed. FREE — this tool never charges. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/work/push.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `items` (array, required): Up to 100 per call. Each entry is {item_id, payload} or a bare string used as the item_id. item_id <=128 chars, payload <=8192 bytes. A queue holds 2000 items over its LIFETIME, finished ones include…
- `max_attempts` (integer): How many times an item may be handed to a worker before it is dead-lettered. Default 3, max 20. Set on first push; later pushes do not change it. Example: '3'.
- `queue_id` (string, required): Your name for this queue. Namespace-scoped: it belongs to the namespace that created it, and only a caller holding that agent_secret can push to or take from it. Example: 'permit-batch-2026-08'.
- `ttl_seconds` (integer): Queue retention. Default 604800 (7d), max 2592000 (30d). Example: '604800'.

### `work_take` (~504 tokens)

Take work, leased so a dead worker cannot lose it

Take up to n items, LEASED not deleted — the same lease semantics as lease()/renew()/release(): a holder, a fence token, an expiry. Two workers can never be handed the same item, because one single-threaded Durable Object owns the queue. IF YOUR PROCESS DIES THE LEASE SIMPLY EXPIRES AND THE ITEMS RETURN TO THE QUEUE with attempts incremented; nothing had to stay alive to notice, and that recovery is the point. EACH ITEM CARRIES ITS OWN FENCE, drawn independently on every take: the token you are given for one item tells you nothing about the token another worker was given for another item, and it is not the previous holder's token plus one. The item's ORDER is `generation` (identical to `attempts`, the number of times it has been handed out) — that is the number to compare and the number to hand to an external store; the fence is the secret. $0.002 when at least one item is handed to you for the FIRST time; a re-take after your own lease expired is free, exactly like mailbox redelivery. An empty or cancelled queue returns nothing, says so, and costs nothing. Costs $0.002 USDC per call via x402 on Base, and ONLY when at least one item was handed to a worker for the FIRST time (a re-take after a lease expired is free); otherwise the same call returns the full answer and settles nothing. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/work/take.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `holder` (string): Who is taking — an instance id you choose, exactly as with lease(). Default 'worker'. Example: 'worker-3'.
- `lease_seconds` (integer): How long you hold them before they return to the queue. Default 300, min 5, max 86400. Example: '300'.
- `n` (integer): How many items to take. 1..25. Default 1. Example: '5'.
- `queue_id` (string, required): The queue to take from. Alias: job_id — a job and its work queue are the same thing. Example: 'permit-batch-2026-08'.

### `work_done` (~364 tokens)

Mark a work item finished

Complete an item you hold. FREE. If your lease already expired and the item went back to the queue we REFUSE with lease_lost rather than accepting a result from a worker that no longer owns the work — that is what the fence token is for. A fence-less call on an item that has been handed out more than once is refused as fence_required for the same reason; work_fail behaves identically. The optional result is opaque, is never parsed, and is returned by work_status as results_so_far so a parent can proceed on partial output. FREE — this tool never charges. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/work/done.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `fence` (integer): The fence token from work_take, for THIS item. Checked exactly when supplied; when omitted we accept the call only while the item has been handed out exactly once, and otherwise refuse with fence_req…
- `item_id` (string, required): The item you were given. Example: 'P-1'.
- `queue_id` (string, required): The queue. Alias: job_id. Example: 'permit-batch-2026-08'.
- `result` (object): Optional opaque outcome, <=8192 bytes. Never parsed or indexed. Example: '{"ok":true}'.

### `work_fail` (~466 tokens)

Give a work item back, or fail it for good

Report that an item did not work out. FREE. THIS IS ALSO THE CORRECT WAY TO HAND AN ITEM BACK WHEN NOTHING WENT WRONG — there is no work_release; retry:true (the default) returns it immediately for another worker instead of waiting out the lease. When its attempts are exhausted it is DEAD-LETTERED and SURFACED in work_status, never silently dropped. With retry:false it is marked permanently failed, stops consuming attempts, and CANNOT BE UNDONE. PASS `fence`: exactly like work_done, if your lease already expired and the item went back to the queue we REFUSE with lease_lost, a stale fence is refused as not_holder, and a fence-less call on an item that has been handed out more than once is refused as fence_required — because accepting it would let a revived worker dead-letter an item another worker is processing right now. FREE — this tool never charges. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/work/fail.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `error` (string): Optional short reason, <=512 chars, surfaced on the dead letter so a human can see WHY it exhausted. Example: 'upstream 503'.
- `fence` (integer): The fence token from work_take, for THIS item. Checked exactly when supplied; when omitted we accept the call only while the item has been handed out exactly once, and otherwise refuse with fence_req…
- `item_id` (string, required): The item you were given. Example: 'P-1'.
- `queue_id` (string, required): The queue. Alias: job_id. Example: 'permit-batch-2026-08'.
- `retry` (boolean): Put it back for another attempt (default true), or fail it permanently (false). Example: 'true'.

### `work_status` (~467 tokens)

How far along is the fan-out

Turn a fan-out from a black box into something you can act on: how many items are pending, leased, done, failed and dead-lettered, the results collected so far, and every dead letter with the error that exhausted it. THIS IS WHAT LETS A PARENT PROCEED WITH 4 OF 5 instead of blocking on a straggler. Counts are produced by scanning the queue, not from counters that can drift. $0.002 ONLY when there is real progress — at least one completion, failure or dead letter — and only when the answer has changed since you last paid for it. An untouched queue charges nothing and says so. The counts are exact and never paged; the results and dead-letter ARRAYS are windowed at 50 rows each and hand you a page token when there is more, so every dead-lettered item is genuinely reachable rather than merely flagged as missing. Paging is free — you are charged per distinct progress state, not per page. Costs $0.002 USDC per call via x402 on Base, and ONLY when done + failed + dead_lettered >= 1, and this exact progress state has not been billed before; otherwise the same call returns the full answer and settles nothing. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/work/status.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `dead_page_token` (string): Optional: the `next_dead_page_token` from a previous call, to read the next page of dead letters. Opaque — hand it back exactly as given. Omit for the first page. Example: 'x:item-0051'.
- `queue_id` (string, required): The queue. Alias: job_id. Example: 'permit-batch-2026-08'.
- `results_page_token` (string): Optional: the `next_results_page_token` from a previous call, to read the next page of results. Opaque — hand it back exactly as given. Omit for the first page. Example: 'c:00001754932100000:item-005…

### `job_cancel` (~245 tokens)

Tell every worker on a job to stop

There is otherwise NO WAY TO TELL FIVE RUNNING AGENTS TO STOP — they finish and bill you for work you no longer want. This sets a durable stop flag on the job. FREE and idempotent. work_take on a cancelled job hands out nothing (and charges nothing), and should_continue answers 'no'. We do not kill anything: workers cooperate by checking, which is the only honest thing a service outside your process can offer. FREE — this tool never charges. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/job/cancel.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `job_id` (string, required): The job to cancel. This is the same identifier as a work queue's queue_id, so cancelling a queue stops its workers. Alias: queue_id. Example: 'permit-batch-2026-08'.
- `reason` (string): Optional short reason, <=512 chars, returned to every worker that asks. Example: 'customer withdrew the request'.

### `should_continue` (~254 tokens)

Should I keep going

The check a worker makes between items. $0.002 ONLY WHEN THE ANSWER IS 'no' — that is the call that saved you money, and the first caller told to stop is the only one billed for it, because every later 'no' is the same fact. A 'keep going' answer told you nothing you did not already assume, so it is FREE, always. An unknown job answers 'keep going' and charges nothing. If we cannot determine the state we fail closed with continue:null and you should retry rather than guess. Costs $0.002 USDC per call via x402 on Base, and ONLY when continue === false, and this cancellation has not been billed before; otherwise the same call returns the full answer and settles nothing. Authenticate with Authorization: Bearer <agent_secret>, or pass agent_key as an argument if your host cannot set headers. Equivalent HTTP route: POST /v1/job/should-continue.

Input parameters:

- `agent_key` (string): Your agent_secret, if your MCP host cannot set the Authorization header. Prefer the header.
- `job_id` (string, required): The job to check. Alias: queue_id. Example: 'permit-batch-2026-08'.

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/com-mcpscores-agent-continuity/mcpfax-continuity#diagnostics

## Score history

- 2026-08-22: 58
- 2026-08-21: 57
- 2026-08-20: 57
- 2026-08-19: 57
- 2026-08-18: 56
- 2026-08-17: 56
- 2026-08-16: 55
- 2026-08-15: 54
- 2026-08-14: 54

## Links

- Remote endpoint: https://mcpfax-continuity.bowling-anthony.workers.dev/mcp
- Website: https://mcpfax-continuity.bowling-anthony.workers.dev/
- Changelog RSS feed: https://verifymcp.io/servers/com-mcpscores-agent-continuity/mcpfax-continuity.xml
- Changelog JSON feed: https://verifymcp.io/servers/com-mcpscores-agent-continuity/mcpfax-continuity.json
- HTML version of this page: https://verifymcp.io/servers/com-mcpscores-agent-continuity/mcpfax-continuity