Micro agents for parsing, validation, encoding, scoring, and structured I/O pipelines.
Maintain this server? Claim it
Call this server's tools from your browser. Nothing to install.
Requests go through mcptry because browsers can't call most MCP servers directly. Header values are sent to the server for that request only and are never stored or logged.
Tool list from our last check. Connect live to refresh it.
Signed acceptance receipt: which deterministic tests a delivered output passed — Runs your deterministic acceptance tests (equals, exists, absent, type, contains, length and number ranges, one-of, sha256, a JSON Schema subset) against a sub-agent's or vendor's JSON output at JSON Pointer paths, and returns per-test results plus a hub-signed receipt over the output hash, the tests hash and the results. Use it before paying for delegated work or releasing the next step. It certi
The delivered JSON (at most 262144 bytes as JCS).
Free text bound into the receipt, e.g. the task id.
This tool isn't marked read-only, so it may change something on the server or in an account you connected.
Pick your client. Values in capitals, like YOUR_TOKEN, are yours to fill in.
Run in a terminal
claude mcp add --transport http writerslogic-agent-infra https://agents.writerslogic.com/mcp/agent-infra
Signed acceptance receipt: which deterministic tests a delivered output passed — Runs your deterministic acceptance tests (equals, exists, absent, type, contains, length and number ranges, one-of, sha256, a JSON Schema subset) against a sub-agent's or vendor's JSON output at JSON Pointer paths, and returns per-test results plus a hub-signed receipt over the output hash, the tests hash and the results. Use it before paying for delegated work or releasing the next step. It certi
| Argument | Type | Description |
|---|---|---|
| label | string | Free text bound into the receipt, e.g. the task id. |
| tests* | array | |
| output* | any | The delivered JSON (at most 262144 bytes as JCS). |
{
"type": "object",
"required": [
"output",
"tests"
],
"properties": {
"label": {
"type": "string",
"maxLength": 200,
"description": "Free text bound into the receipt, e.g. the task id."
},
"tests": {
"type": "array",
"items": {
"type": "object",
"required": [
"id",
"kind"
],
"properties": {
"id": {
"type": "string",
"pattern": "^[A-Za-z0-9_.:-]{1,64}$"
},
"max": {
"type": "number"
},
"min": {
"type": "number"
},
"kind": {
"enum": [
"equals",
"not-equals",
"exists",
"absent",
"type",
"contains",
"length-between",
"number-between",
"one-of",
"sha256",
"schema"
],
"type": "string"
},
"path": {
"type": "string",
"maxLength": 500,
"description": "RFC 6901 JSON Pointer into output; empty or omitted = the whole output."
},
"value": {
"description": "equals/not-equals/contains: the JSON value; type: a JSON type name; one-of: an array; sha256: lowercase hex; schema: a hub-subset JSON Schema."
}
},
"additionalProperties": false
},
"maxItems": 100,
"minItems": 1
},
"output": {
"description": "The delivered JSON (at most 262144 bytes as JCS)."
}
},
"additionalProperties": false
}Does a change to the approved thing invalidate the approval under a materiality policy? — Compares what a human or system approved with what is about to be executed (a quote, order, plan, diff summary: any JSON) under a caller-supplied materiality policy: per-path rules exact / ignore / numeric tolerance (absolute or percent) / no-increase / no-decrease, with the longest matching path winning and a default for unlisted paths. Also covers quote revisions (approved revision number must e
| Argument | Type | Description |
|---|---|---|
| asOf | string | RFC 3339 instant for the expiry check; no clock is read. |
| policy | object | |
| current* | any | The version about to be executed (JSON). |
| approved* | any | The approved snapshot (JSON). |
| approvedAt | string | RFC 3339 instant. |
| currentRevision | integer | |
| validForSeconds | integer | |
| approvedRevision | integer | |
| requireSameRevision |
Which derived artifacts must be rechecked after these inputs changed? (bounded dependency graph) — Given a dependency graph of artifacts (each lists the artifact ids it was derived from) and the ids that changed, returns every artifact that transitively depends on a change, in an order safe to recompute (inputs before dependents), and the artifacts that are unaffected. A cycle or an unknown input id is a defect in the graph and returns fail with the cycle path. Changed ids that are unknown fail
| Argument | Type | Description |
|---|---|---|
| changed* | array | |
| artifacts* | array |
{
"type": "object",
"required": [
"artifacts",
"changed"
],
"properties": {
"changed": {
"type": "array",
"items": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"maxItems": 500,
"minItems": 1
},
"artifacts": {
"type": "array",
"items": {
"type": "object",
"required": [
"id"
],
"properties": {
"id": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"inputs": {
"type": "array",
"items": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"maxItems": 50,
"description": "Ids of artifacts this one is derived from."
}
},
"additionalProperties": false
},
"maxItems": 500,
"minItems": 1
}
},
"additionalProperties": false
}Find assumptions that disagree across agents (currency, timezone, version, customer id, ...) — Takes assumptions that several agents or steps hold about the same fact (key, value, who) and reports every key where the values differ, naming the conflicting pairs and whether they differ only by case or whitespace (a formatting difference) or in substance (USD vs EUR, a different id, a different version). Optionally requires each listed agent to state each required key; a missing statement is u
| Argument | Type | Description |
|---|---|---|
| agents | array | Agents expected to state the required keys. |
| assumptions* | array | |
| requiredKeys | array | Keys every listed agent must state. |
{
"type": "object",
"required": [
"assumptions"
],
"properties": {
"agents": {
"type": "array",
"items": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"maxItems": 50,
"description": "Agents expected to state the required keys."
},
"assumptions": {
"type": "array",
"items": {
"type": "object",
"required": [
"agent",
"key",
"value"
],
"properties": {
"key": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"agent": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"value": {
"description": "String (≤ 200 chars), number or boolean."
}
},
"additionalProperties": false
},
"maxItems": 500,
"minItems": 1
},
"requiredKeys": {
"type": "array",
"items": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"maxItems": 50,
"description": "Keys every listed agent must state."
}
},
"additionalProperties": false
}Check that what a message says is attached matches the attachments actually supplied — Compares a message's wording with its attachment list: 'see attached' with nothing attached, a named file (report.pdf) that is not in the list, a kind of file mentioned (the spreadsheet, a screenshot, the PDF) that no attachment matches by extension or MIME type, and a stated count ('two files') that differs from the list; attachments the text never mentions are listed. Mentions inside a negation
| Argument | Type | Description |
|---|---|---|
| text* | string | Message body. |
| attachments* | array | The attachments actually present; may be empty. |
{
"type": "object",
"required": [
"text",
"attachments"
],
"properties": {
"text": {
"type": "string",
"maxLength": 20000,
"minLength": 1,
"description": "Message body."
},
"attachments": {
"type": "array",
"items": {
"type": "object",
"required": [
"name"
],
"properties": {
"name": {
"type": "string",
"maxLength": 260,
"minLength": 1,
"description": "File name."
},
"bytes": {
"type": "integer",
"maximum": 10000000000,
"minimum": 0
},
"mimeType": {
"type": "string",
"maxLength": 120
}
},
"additionalProperties": false
},
"maxItems": 50,
"description": "The attachments actually present; may be empty."
}
},
"additionalProperties": false
}Check that a result-cache key contains every input that changes the result, and nothing volatile — Given the inputs of a cached computation (each declared as influencing the output or not, optionally volatile) and the list of inputs the cache key is built from, finds influential inputs missing from the key (stale or wrong hits), volatile inputs inside it (the cache never hits), unknown-influence inputs left out, and, for private results, a missing tenant dimension (cross-tenant leak). When valu
| Argument | Type | Description |
|---|---|---|
| scope | string | Namespace mixed into the digest. |
| inputs* | array | |
| private | boolean | The result is per-tenant or per-user. |
| keyParts* | array | Names of the inputs the key is built from. |
| tenantInput | string | Name of the input that identifies the tenant or user; required in the key when private. |
{
"type": "object",
"required": [
"inputs",
"keyParts"
],
"properties": {
"scope": {
"type": "string",
"maxLength": 200,
"description": "Namespace mixed into the digest."
},
"inputs": {
"type": "array",
"items": {
"type": "object",
"required": [
"name",
"influencesOutput"
],
"properties": {
"name": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"value": {
"description": "Optional value, used only to compute the key digest."
},
"volatile": {
"type": "boolean",
"description": "Changes on every call (timestamp, request id, nonce)."
},
"influencesOutput": {
"enum": [
"yes",
"no",
"unknown"
],
"type": "string"
}
},
"additionalProperties": false
},
"maxItems": 100,
"minItems": 1
},
"private": {
"type": "boolean",
"description": "The result is per-tenant or per-user."
},
"keyParts": {
"type": "array",
"items": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"maxItems": 100,
"description": "Names of the inputs the key is built from."
},
"tenantInput": {
"type": "string",
"maxLength": 200,
"minLength": 1,
"description": "Name of the input that identifies the tenant or user; required in the key when private."
}
},
"additionalProperties": false
}Chat completion, deep tier (12k in, 2k out) — OpenAI-style chat completion served by the hub's provider router (strongest available model, up to 12000 input tokens and 2048 output tokens per call), with a signed receipt that binds the provider, model, token usage and the hashes of your messages and the reply. Supports optional strict json_schema output returned both parsed and as a string. Does not stream, call tools or functions, accept imag
| Argument | Type | Description |
|---|---|---|
| model | string | Accepted and ignored: the hub routes by tier (the resource you paid for). Echoed as requested_model. |
| top_p | number | Accepted and ignored. |
| messages* | array | Conversation, oldest first; the last message must have role user. At most 200000 characters in total. System messages are joined into the instructions. |
| max_tokens | integer | Upper bound on the reply in tokens; defaults to 1024. A value above the tier cap is rejected with 400. |
| temperature | number | Accepted and ignored. |
| response_format | object | Either {"type":"text"} (default) or {"type":"json_schema","json_schema":{name,schema}}. The schema is always enforced strictly: root object, every property required, additionalProperties false, keywords limited to type, description, properties, required, additionalProperties, items, enum. |
Chat completion, fast tier (8k in, 1k out) — OpenAI-style chat completion served by the hub's provider router (small, fast model, up to 8000 input tokens and 1024 output tokens per call), with a signed receipt that binds the provider, model, token usage and the hashes of your messages and the reply. Supports optional strict json_schema output returned both parsed and as a string. Does not stream, call tools or functions, accept images, or us
| Argument | Type | Description |
|---|---|---|
| model | string | Accepted and ignored: the hub routes by tier (the resource you paid for). Echoed as requested_model. |
| top_p | number | Accepted and ignored. |
| messages* | array | Conversation, oldest first; the last message must have role user. At most 200000 characters in total. System messages are joined into the instructions. |
| max_tokens | integer | Upper bound on the reply in tokens; defaults to 1024. A value above the tier cap is rejected with 400. |
| temperature | number | Accepted and ignored. |
| response_format | object | Either {"type":"text"} (default) or {"type":"json_schema","json_schema":{name,schema}}. The schema is always enforced strictly: root object, every property required, additionalProperties false, keywords limited to type, description, properties, required, additionalProperties, items, enum. |
Chat completion, standard tier (12k in, 2k out) — OpenAI-style chat completion served by the hub's provider router (mid-size general model, up to 12000 input tokens and 2048 output tokens per call), with a signed receipt that binds the provider, model, token usage and the hashes of your messages and the reply. Supports optional strict json_schema output returned both parsed and as a string. Does not stream, call tools or functions, accept images,
| Argument | Type | Description |
|---|---|---|
| model | string | Accepted and ignored: the hub routes by tier (the resource you paid for). Echoed as requested_model. |
| top_p | number | Accepted and ignored. |
| messages* | array | Conversation, oldest first; the last message must have role user. At most 200000 characters in total. System messages are joined into the instructions. |
| max_tokens | integer | Upper bound on the reply in tokens; defaults to 1024. A value above the tier cap is rejected with 400. |
| temperature | number | Accepted and ignored. |
| response_format | object | Either {"type":"text"} (default) or {"type":"json_schema","json_schema":{name,schema}}. The schema is always enforced strictly: root object, every property required, additionalProperties false, keywords limited to type, description, properties, required, additionalProperties, items, enum. |
Split text into chunks under a hard token cap without cutting a table, sentence or code fence — Plans chunk boundaries for text an agent must feed to a model in pieces: every chunk is at most maxTokens in the named tokenizer (o200k_base or cl100k_base, verified by counting each finished chunk), boundaries fall only between sentences, blocks, whole Markdown or HTML tables and whole code fences, headings stay with the text that follows, and the chunks tile the input exactly (concatenating the
| Argument | Type | Description |
|---|---|---|
| text* | string | Text to chunk (Markdown, plain text or HTML tables). |
| maxTokens* | integer | Hard cap per chunk. |
| tokenizer* | string | o200k_base or cl100k_base. Any other name (including Claude models) returns status unsupported for items that need counting; caller token counts are always accepted. |
| includeText | boolean | Also return each chunk's text. Default false (slice by span). |
{
"type": "object",
"required": [
"text",
"maxTokens",
"tokenizer"
],
"properties": {
"text": {
"type": "string",
"maxLength": 100000,
"minLength": 1,
"description": "Text to chunk (Markdown, plain text or HTML tables)."
},
"maxTokens": {
"type": "integer",
"maximum": 1000000,
"minimum": 32,
"description": "Hard cap per chunk."
},
"tokenizer": {
"type": "string",
"maxLength": 64,
"minLength": 1,
"description": "o200k_base or cl100k_base. Any other name (including Claude models) returns status unsupported for items that need counting; caller token counts are always accepted."
},
"includeText": {
"type": "boolean",
"description": "Also return each chunk's text. Default false (slice by span)."
}
},
"additionalProperties": false
}Locate quoted text in a source with exact offsets, or classify it as normalized, elided, paraphrased or absent — Finds each quote an agent attributes to a source text and returns where it sits: exact offsets in UTF-16, code points, UTF-8 bytes and graphemes, so the span slices back to the matched text. Tries an exact match, then a match tolerant of whitespace, curly vs straight quotes, dash types, ellipses, invisible characters and Unicode forms (NFC/NFD, ligatures), naming which normalizations were needed,
| Argument | Type | Description |
|---|---|---|
| quotes* | array | Up to 50 quotes, 40000 characters in total. |
| source* | string | Text the quotes are claimed to come from. |
| tolerate | array | Normalizations that still count as a match. Default: all six. |
| exactOnly | boolean | Count only byte-identical matches as pass; normalized matches become fail. Default false. |
| minLength | integer | Quotes shorter than this many characters (after trimming quote marks) are too-short and give unknown. Default 8. |
| ignoreCase | boolean | Also tolerate case differences (reported as a normalization). Default false. |
{
"type": "object",
"required": [
"source",
"quotes"
],
"properties": {
"quotes": {
"type": "array",
"items": {
"type": "object",
"required": [
"text"
],
"properties": {
"id": {
"type": "string",
"maxLength": 100,
"description": "Echoed back."
},
"text": {
"type": "string",
"maxLength": 2000,
"minLength": 1,
"description": "The quoted text."
}
},
"additionalProperties": false
},
"maxItems": 50,
"minItems": 1,
"description": "Up to 50 quotes, 40000 characters in total."
},
"source": {
"type": "string",
"maxLength": 100000,
"minLength": 1,
"description": "Text the quotes are claimed to come from."
},
"tolerate": {
"type": "array",
"items": {
"enum": [
"whitespace",
"quotes",
"dashes",
"ellipsis",
"invisible",
"unicode"
],
"type": "string"
},
"maxItems": 6,
"description": "Normalizations that still count as a match. Default: all six."
},
"exactOnly": {
"type": "boolean",
"description": "Count only byte-identical matches as pass; normalized matches become fail. Default false."
},
"minLength": {
"type": "integer",
"maximum": 200,
"minimum": 1,
"description": "Quotes shorter than this many characters (after trimming quote marks) are too-short and give unknown. Default 8."
},
"ignoreCase": {
"type": "boolean",
"description": "Also tolerate case differences (reported as a normalization). Default false."
}
},
"additionalProperties": false
}Check that every write step in a multi-step plan has an undo step, and give the rollback order — For an agent plan made of steps with declared effects (read or write), checks every write in the plan, run or not, has a compensation step that exists, is itself a write, is not its own compensation, and that the dependencies have no cycle; flags writes declared irreversible; and, given which steps have completed, returns the compensations to run in reverse completion order. Does not judge whether
| Argument | Type | Description |
|---|---|---|
| steps* | array | |
| completed | array | Step ids completed so far, in completion order. Only used for rollbackOrder and to say an irreversible write has already run; coverage is always checked for the whole plan. |
{
"type": "object",
"required": [
"steps"
],
"properties": {
"steps": {
"type": "array",
"items": {
"type": "object",
"required": [
"id",
"effect"
],
"properties": {
"id": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"effect": {
"enum": [
"read",
"write"
],
"type": "string"
},
"dependsOn": {
"type": "array",
"items": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"maxItems": 20
},
"compensation": {
"type": "string",
"maxLength": 200,
"minLength": 1,
"description": "Id of the step that undoes this one."
},
"irreversible": {
"type": "boolean",
"description": "Declared impossible to undo (send email, wire transfer)."
}
},
"additionalProperties": false
},
"maxItems": 100,
"minItems": 1
},
"completed": {
"type": "array",
"items": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"maxItems": 100,
"description": "Step ids completed so far, in completion order. Only used for rollbackOrder and to say an irreversible write has already run; coverage is always checked for the whole plan."
}
},
"additionalProperties": false
}Classify a confirmation message as submitted, pending, reserved or completed from caller or default phrases — Reads a confirmation page, email or API message and decides which state it states: submitted, pending, reserved or completed, using phrase lists the caller supplies (preferred, because wording is provider-specific) plus an optional default English list. Matches are whole-word, case- and typography-insensitive, returned with offsets in UTF-16, code points, UTF-8 bytes and graphemes, and a match ins
| Argument | Type | Description |
|---|---|---|
| text* | string | Confirmation text. |
| rules | array | Caller phrase lists; with these present the defaults are off unless useDefaults is true. |
| precedence | array | When several states match, the first one listed wins. Without it a conflict is unknown. |
| useDefaults | boolean | Include the default English phrases. Default true only when rules is absent. |
{
"type": "object",
"required": [
"text"
],
"properties": {
"text": {
"type": "string",
"maxLength": 20000,
"minLength": 1,
"description": "Confirmation text."
},
"rules": {
"type": "array",
"items": {
"type": "object",
"required": [
"state",
"phrases"
],
"properties": {
"state": {
"enum": [
"submitted",
"pending",
"reserved",
"completed"
],
"type": "string"
},
"phrases": {
"type": "array",
"items": {
"type": "string",
"maxLength": 200
},
"maxItems": 30
}
},
"additionalProperties": false
},
"maxItems": 20,
"description": "Caller phrase lists; with these present the defaults are off unless useDefaults is true."
},
"precedence": {
"type": "array",
"items": {
"enum": [
"submitted",
"pending",
"reserved",
"completed"
],
"type": "string"
},
"maxItems": 4,
"description": "When several states match, the first one listed wins. Without it a conflict is unknown."
},
"useDefaults": {
"type": "boolean",
"description": "Include the default English phrases. Default true only when rules is absent."
}
},
"additionalProperties": false
}Check that earlier constraints (numbers, dates, codes, quoted terms, negations) survive into a later plan or summary — Takes the constraints an agent was given (budget caps, deadlines, identifiers, prohibitions) and a later artifact (plan, summary, handoff, tool arguments) and reports for each constraint whether its concrete atoms still appear: numbers with their unit or currency, ISO dates, codes, quoted terms, or caller-listed anchor strings, with offsets. For a negated constraint it also reports whether the clo
| Argument | Type | Description |
|---|---|---|
| target* | string | The later artifact that must still honor the constraints. |
| constraints* | array | Up to 50; 20000 characters of constraint text in total. |
{
"type": "object",
"required": [
"constraints",
"target"
],
"properties": {
"target": {
"type": "string",
"maxLength": 60000,
"minLength": 1,
"description": "The later artifact that must still honor the constraints."
},
"constraints": {
"type": "array",
"items": {
"type": "object",
"required": [
"id",
"text"
],
"properties": {
"id": {
"type": "string",
"maxLength": 100,
"minLength": 1,
"description": "Echoed back."
},
"text": {
"type": "string",
"maxLength": 2000,
"minLength": 1,
"description": "The constraint in plain words."
},
"anchors": {
"type": "array",
"items": {
"type": "string",
"maxLength": 200
},
"maxItems": 20,
"description": "Exact strings that must appear (case-insensitive); replaces atom extraction for this constraint."
}
},
"additionalProperties": false
},
"maxItems": 50,
"minItems": 1,
"description": "Up to 50; 20000 characters of constraint text in total."
}
},
"additionalProperties": false
}Pick context blocks that fit a token budget, keeping mandatory blocks and their dependencies — Chooses which context items an agent should put into a prompt without exceeding a token budget: every mandatory item and everything it depends on is always included, then optional items by descending priority (each with the dependencies it pulls in) while they fit. Token counts come from the caller or from o200k_base / cl100k_base; any other tokenizer name returns unsupported (there is no Claude t
| Argument | Type | Description |
|---|---|---|
| items* | array | Up to 500 items, 300000 characters of text in total. |
| budget* | integer | Maximum total tokens (including perItemOverhead per included item). |
| tokenizer | string | o200k_base or cl100k_base. Any other name (including Claude models) returns status unsupported for items that need counting; caller token counts are always accepted. |
| perItemOverhead | integer | Tokens added per included item for separators or wrappers. Default 0. |
{
"type": "object",
"required": [
"items",
"budget"
],
"properties": {
"items": {
"type": "array",
"items": {
"type": "object",
"required": [
"id"
],
"properties": {
"id": {
"type": "string",
"maxLength": 100,
"minLength": 1,
"description": "Unique id."
},
"text": {
"type": "string",
"maxLength": 100000,
"description": "Content to count when tokens is not given."
},
"tokens": {
"type": "integer",
"maximum": 100000000,
"minimum": 0,
"description": "Caller-supplied token count; always accepted and used in preference to counting text."
},
"priority": {
"type": "number",
"maximum": 1000000,
"minimum": -1000000,
"description": "Higher is packed first among optional items. Default 0."
},
"dependsOn": {
"type": "array",
"items": {
"type": "string",
"maxLength": 100
},
"maxItems": 50,
"description": "Ids that must be included whenever this item is."
},
"mandatory": {
"type": "boolean",
"description": "Always included, with its dependencies; if they cannot fit the result is fail."
}
},
"additionalProperties": false
},
"maxItems": 500,
"minItems": 1,
"description": "Up to 500 items, 300000 characters of text in total."
},
"budget": {
"type": "integer",
"maximum": 100000000,
"minimum": 1,
"description": "Maximum total tokens (including perItemOverhead per included item)."
},
"tokenizer": {
"type": "string",
"maxLength": 64,
"description": "o200k_base or cl100k_base. Any other name (including Claude models) returns status unsupported for items that need counting; caller token counts are always accepted."
},
"perItemOverhead": {
"type": "integer",
"maximum": 100000,
"minimum": 0,
"description": "Tokens added per included item for separators or wrappers. Default 0."
}
},
"additionalProperties": false
}Choose which old messages to drop to hit a token target without touching the cached prompt prefix — Given a conversation, the index of the last message inside the provider's cached prefix, and a token target, returns which messages to drop: whole tool call plus tool result pairs (so no result is left without its call) and messages the caller marked droppable, oldest first or largest first, never inside the cached prefix, never the most recent keepRecent messages, never pinned ones. Everything up
| Argument | Type | Description |
|---|---|---|
| messages* | array | Up to 500; 400000 characters of content in total. |
| strategy | string | Order in which droppable units are removed. Default oldest-first. |
| tokenizer | string | o200k_base or cl100k_base. Any other name (including Claude models) returns status unsupported for items that need counting; caller token counts are always accepted. |
| keepRecent | integer | Most recent messages that are never dropped. Default 4. |
| targetTokens* | integer | Total tokens to get at or under. |
| cacheBreakpoint* | integer | Index of the last message inside the cached prefix; -1 when nothing is cached. |
{
"type": "object",
"required": [
"messages",
"cacheBreakpoint",
"targetTokens"
],
"properties": {
"messages": {
"type": "array",
"items": {
"type": "object",
"required": [
"role"
],
"properties": {
"id": {
"type": "string",
"maxLength": 100
},
"kind": {
"enum": [
"text",
"tool_call",
"tool_result"
],
"type": "string",
"description": "tool_call: assistant message holding a tool call; tool_result: its output. Pairs are matched by toolCallId. Default text."
},
"role": {
"type": "string",
"maxLength": 32,
"minLength": 1,
"description": "user, assistant, tool, system, ..."
},
"pinned": {
"type": "boolean",
"description": "Never dropped."
},
"tokens": {
"type": "integer",
"maximum": 100000000,
"minimum": 0,
"description": "Caller-supplied token count; always accepted."
},
"content": {
"type": "string",
"maxLength": 100000,
"description": "Message text, used only to count tokens when tokens is absent."
},
"droppable": {
"type": "boolean",
"description": "A text message that may be dropped (tool pairs are droppable by default)."
},
"toolCallId": {
"type": "string",
"maxLength": 200,
"description": "Pairs a tool_call with its tool_result."
}
},
"additionalProperties": false
},
"maxItems": 500,
"minItems": 1,
"description": "Up to 500; 400000 characters of content in total."
},
"strategy": {
"enum": [
"oldest-first",
"largest-first"
],
"type": "string",
"description": "Order in which droppable units are removed. Default oldest-first."
},
"tokenizer": {
"type": "string",
"maxLength": 64,
"description": "o200k_base or cl100k_base. Any other name (including Claude models) returns status unsupported for items that need counting; caller token counts are always accepted."
},
"keepRecent": {
"type": "integer",
"maximum": 100,
"minimum": 0,
"description": "Most recent messages that are never dropped. Default 4."
},
"targetTokens": {
"type": "integer",
"maximum": 100000000,
"minimum": 0,
"description": "Total tokens to get at or under."
},
"cacheBreakpoint": {
"type": "integer",
"maximum": 499,
"minimum": -1,
"description": "Index of the last message inside the cached prefix; -1 when nothing is cached."
}
},
"additionalProperties": false
}Find dangling and duplicated cross-references (Section 3.2, Table 4, Figure 2, [7]) in a document — Scans a document for the targets it defines (numbered headings, Table/Figure/Listing/Equation captions at line start, Appendix/Annex headings, [n] bibliography entries, [^id] footnote definitions) and the references it makes to them ('see Section 3.2', 'Tables 2 and 4', 'Figures 3 to 5', '[7]', '[^note]'), and reports references with no target, targets defined twice, and targets never referenced,
| Argument | Type | Description |
|---|---|---|
| text* | string | Document text (plain text or Markdown). |
{
"type": "object",
"required": [
"text"
],
"properties": {
"text": {
"type": "string",
"maxLength": 150000,
"minLength": 1,
"description": "Document text (plain text or Markdown)."
}
},
"additionalProperties": false
}Can this plan of steps finish inside the remaining time, in the expected case and the worst case? — Takes steps with expected and worst-case durations, dependencies (steps with no dependency between them run in parallel), retries with backoff, and the time remaining, and computes the critical path for both cases. Verdict guaranteed (worst case fits: pass), likely (only the expected case fits: unknown) or infeasible (even the expected case does not fit: fail), with the slack and the critical-path
| Argument | Type | Description |
|---|---|---|
| steps* | array | |
| overheadMs | integer | Fixed time to reserve for settlement, serialization, etc. |
| remainingMs* | integer | Time left to the hard deadline, measured by the caller. |
{
"type": "object",
"required": [
"steps",
"remainingMs"
],
"properties": {
"steps": {
"type": "array",
"items": {
"type": "object",
"required": [
"id",
"expectedMs",
"worstMs"
],
"properties": {
"id": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"after": {
"type": "array",
"items": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"maxItems": 20,
"description": "Step ids that must finish first."
},
"retries": {
"type": "integer",
"maximum": 10,
"minimum": 0,
"description": "Retries after a failed attempt; the worst case runs them all."
},
"worstMs": {
"type": "integer",
"maximum": 86400000,
"minimum": 0,
"description": "Worst-case duration of one attempt. Must be at least expectedMs."
},
"backoffMs": {
"type": "integer",
"maximum": 3600000,
"minimum": 0,
"description": "Wait before each retry (constant)."
},
"expectedMs": {
"type": "integer",
"maximum": 86400000,
"minimum": 0
}
},
"additionalProperties": false
},
"maxItems": 100,
"minItems": 1
},
"overheadMs": {
"type": "integer",
"maximum": 3600000,
"minimum": 0,
"description": "Fixed time to reserve for settlement, serialization, etc."
},
"remainingMs": {
"type": "integer",
"maximum": 604800000,
"minimum": 0,
"description": "Time left to the hard deadline, measured by the caller."
}
},
"additionalProperties": false
}Group webhook deliveries by identity within a time window and decide: process, dedupe, retry, reconcile or abstain — Given previously seen deliveries (identity, receivedAt, payload or digest, handling outcome) and a new incoming one, finds earlier deliveries with the same identity inside the window and returns process (none), dedupe (same payload already processed), retry (earlier ones all failed), reconcile (an earlier one is in flight or unknown, or the same identity arrives with a different payload) or abstai
| Argument | Type | Description |
|---|---|---|
| history* | array | |
| incoming* | object | |
| windowMode | string | from-first (default): a group's window starts at its first delivery. sliding: each delivery extends the window. |
| windowSeconds* | integer |
{
"type": "object",
"required": [
"history",
"incoming",
"windowSeconds"
],
"properties": {
"history": {
"type": "array",
"items": {
"type": "object",
"required": [
"identity",
"receivedAt"
],
"properties": {
"id": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"outcome": {
"enum": [
"processed",
"failed",
"in-flight",
"unknown"
],
"type": "string",
"description": "What happened when this delivery was handled (history only)."
},
"payload": {
"description": "Event body; hashed with RFC 8785 canonical JSON to detect conflicting duplicates."
},
"identity": {
"type": "string",
"maxLength": 200,
"minLength": 1,
"description": "Delivery identity: the provider's event id, or a key built from the fields that define the event."
},
"receivedAt": {
"type": "string",
"maxLength": 40,
"description": "RFC 3339 instant."
},
"payloadDigest": {
"type": "string",
"maxLength": 128,
"minLength": 8,
"description": "Alternative to payload: a digest the caller computed."
}
},
"additionalProperties": false
},
"maxItems": 500
},
"incoming": {
"type": "object",
"required": [
"identity",
"receivedAt"
],
"properties": {
"id": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"outcome": {
"enum": [
"processed",
"failed",
"in-flight",
"unknown"
],
"type": "string",
"description": "What happened when this delivery was handled (history only)."
},
"payload": {
"description": "Event body; hashed with RFC 8785 canonical JSON to detect conflicting duplicates."
},
"identity": {
"type": "string",
"maxLength": 200,
"minLength": 1,
"description": "Delivery identity: the provider's event id, or a key built from the fields that define the event."
},
"receivedAt": {
"type": "string",
"maxLength": 40,
"description": "RFC 3339 instant."
},
"payloadDigest": {
"type": "string",
"maxLength": 128,
"minLength": 8,
"description": "Alternative to payload: a digest the caller computed."
}
},
"additionalProperties": false
},
"windowMode": {
"enum": [
"from-first",
"sliding"
],
"type": "string",
"description": "from-first (default): a group's window starts at its first delivery. sliding: each delivery extends the window."
},
"windowSeconds": {
"type": "integer",
"maximum": 2592000,
"minimum": 1
}
},
"additionalProperties": false
}Find unresolved references (that one, the former, tomorrow, next week) and return clarification questions — Scans a user or tool message for phrases that cannot be understood without context: demonstratives ('that one', 'the latter'), back-references ('as before', 'the usual'), and relative dates or times ('tomorrow', 'next Friday', 'end of month', 'soon'), each with offsets and a clarification question. Given a caller anchor (asOf instant plus IANA time zone) it resolves only unambiguous day offsets (t
| Argument | Type | Description |
|---|---|---|
| text* | string | Message to check. |
| anchor | object | Reference time for resolving unambiguous relative dates. |
| candidates | array | Items recently in play; echoed on reference slots for the caller to ask with. Never chosen automatically. |
{
"type": "object",
"required": [
"text"
],
"properties": {
"text": {
"type": "string",
"maxLength": 20000,
"minLength": 1,
"description": "Message to check."
},
"anchor": {
"type": "object",
"required": [
"asOf",
"timeZone"
],
"properties": {
"asOf": {
"type": "string",
"maxLength": 40,
"description": "ISO 8601 instant with Z/offset, or a plain YYYY-MM-DD local date."
},
"timeZone": {
"type": "string",
"maxLength": 64,
"minLength": 1,
"description": "IANA zone, e.g. Europe/Berlin."
}
},
"description": "Reference time for resolving unambiguous relative dates.",
"additionalProperties": false
},
"candidates": {
"type": "array",
"items": {
"type": "string",
"maxLength": 200
},
"maxItems": 20,
"description": "Items recently in play; echoed on reference slots for the caller to ask with. Never chosen automatically."
}
},
"additionalProperties": false
}Check that a sub-agent delegation states objective, acceptance criteria, budget, evidence and stop conditions — Checks the brief an agent is about to hand to another agent: the required parts are present and non-empty (objective, acceptance criteria, a budget with at least one positive numeric bound, required evidence, stop conditions; output format if required), nothing is duplicated, and acceptance criteria are not made only of vague wording (a small labelled word list: good, appropriate, if possible ...)
| Argument | Type | Description |
|---|---|---|
| budget | object | |
| require | array | Parts that must be present. Default: objective, acceptanceCriteria, budget, evidenceRequired, stopConditions. |
| objective | string | |
| outputFormat | string | |
| stopConditions | array | When the delegate must stop and report (done, blocked, budget spent). |
| evidenceRequired | array | What the delegate must return as proof (links, test output, file paths). |
| acceptanceCriteria | array |
{
"type": "object",
"required": [],
"properties": {
"budget": {
"type": "object",
"properties": {
"maxUsd": {
"type": "number",
"maximum": 1000000,
"minimum": 0
},
"maxTokens": {
"type": "integer",
"maximum": 10000000000,
"minimum": 0
},
"maxSeconds": {
"type": "integer",
"maximum": 31536000,
"minimum": 0
},
"maxToolCalls": {
"type": "integer",
"maximum": 10000000,
"minimum": 0
}
},
"additionalProperties": false
},
"require": {
"type": "array",
"items": {
"enum": [
"objective",
"acceptanceCriteria",
"budget",
"evidenceRequired",
"stopConditions",
"outputFormat"
],
"type": "string"
},
"maxItems": 6,
"minItems": 1,
"description": "Parts that must be present. Default: objective, acceptanceCriteria, budget, evidenceRequired, stopConditions."
},
"objective": {
"type": "string",
"maxLength": 2000
},
"outputFormat": {
"type": "string",
"maxLength": 2000
},
"stopConditions": {
"type": "array",
"items": {
"type": "string",
"maxLength": 2000
},
"maxItems": 30,
"description": "When the delegate must stop and report (done, blocked, budget spent)."
},
"evidenceRequired": {
"type": "array",
"items": {
"type": "string",
"maxLength": 2000
},
"maxItems": 30,
"description": "What the delegate must return as proof (links, test output, file paths)."
},
"acceptanceCriteria": {
"type": "array",
"items": {
"type": "string",
"maxLength": 2000
},
"maxItems": 30
}
},
"additionalProperties": false
}DOI check: exists, retracted, or fabricated (batch of 20) — Checks up to 20 DOIs in one call against Crossref (including its Retraction Watch notices), OpenAlex and the doi.org Handle registry. Per DOI: FOUND with title and year, RETRACTED, EXPRESSION_OF_CONCERN, CORRECTED, REGISTERED_NOT_INDEXED, NOT_REGISTERED (no such DOI anywhere: likely fabricated), INVALID_DOI or UNVERIFIED. For research agents and RAG pipelines that cite papers: run every DOI throug
| Argument | Type | Description |
|---|---|---|
| dois* | array | Bare DOIs, doi: prefixes or https://doi.org/ URLs. |
{
"type": "object",
"required": [
"dois"
],
"properties": {
"dois": {
"type": "array",
"items": {
"type": "string",
"maxLength": 300,
"minLength": 1
},
"maxItems": 20,
"minItems": 1,
"description": "Bare DOIs, doi: prefixes or https://doi.org/ URLs."
}
},
"additionalProperties": false
}Check whether a saved interaction recipe still applies to the current version of a page — Compares a recipe (ordered steps naming selectors from an earlier dom-skeleton call), the saved skeleton elements those selectors came from, and the current page HTML. Per step it reports matched (same selector, same tag, type, role and name), changed (selector still exists but the element differs), moved (the same element now has a different selector, given as newSelector), ambiguous (several cur
| Argument | Type | Description |
|---|---|---|
| html* | string | Current page HTML. |
| saved* | array | elements from an earlier dom-skeleton response. |
| recipe* | object |
{
"type": "object",
"required": [
"recipe",
"saved",
"html"
],
"properties": {
"html": {
"type": "string",
"maxLength": 100000,
"minLength": 1,
"description": "Current page HTML."
},
"saved": {
"type": "array",
"items": {
"type": "object",
"properties": {
"tag": {
"type": "string"
},
"href": {
"type": "string"
},
"name": {
"type": "string",
"description": "Best-effort accessible name (aria-label, aria-labelledby, label, text, placeholder, title, alt, value), at most 80 characters."
},
"role": {
"type": "string"
},
"type": {
"type": "string"
},
"repeats": {
"type": "integer",
"description": "Elements with the same tag, type, role, name and href collapsed into this one (the first)."
},
"disabled": {
"type": "boolean"
},
"required": {
"type": "boolean"
},
"selector": {
"type": "string",
"description": "CSS selector that matches exactly this element in the supplied HTML."
},
"nameSource": {
"type": "string"
},
"selectorKind": {
"enum": [
"id",
"data-testid",
"name",
"aria-label",
"path"
],
"type": "string"
}
},
"additionalProperties": false
},
"maxItems": 300,
"minItems": 1,
"description": "elements from an earlier dom-skeleton response."
},
"recipe": {
"type": "object",
"required": [
"steps"
],
"properties": {
"steps": {
"type": "array",
"items": {
"type": "object",
"required": [
"selector"
],
"properties": {
"action": {
"type": "string",
"maxLength": 100,
"description": "Free-form label, echoed back."
},
"selector": {
"type": "string",
"maxLength": 500,
"minLength": 1,
"description": "A selector from the saved skeleton."
}
},
"additionalProperties": false
},
"maxItems": 100,
"minItems": 1
}
},
"additionalProperties": false
}
},
"additionalProperties": false
}List the interactive elements of an HTML page with stable CSS selectors — Reduces an HTML document to the elements an agent can act on: links with href, buttons, inputs (not type=hidden), selects, textareas, [role], [onclick], contenteditable, each with tag, type, role, best-effort accessible name (including label associations) and a CSS selector that matches exactly that element, preferring a stable id, then a data-testid-style attribute, name, aria-label, then a struc
| Argument | Type | Description |
|---|---|---|
| html* | string | HTML source. |
| dedupe | boolean | Collapse elements with identical tag, type, role, name and href. Default true. |
| maxElements | integer | Maximum elements returned. Default 100. |
{
"type": "object",
"required": [
"html"
],
"properties": {
"html": {
"type": "string",
"maxLength": 100000,
"minLength": 1,
"description": "HTML source."
},
"dedupe": {
"type": "boolean",
"description": "Collapse elements with identical tag, type, role, name and href. Default true."
},
"maxElements": {
"type": "integer",
"maximum": 300,
"minimum": 1,
"description": "Maximum elements returned. Default 100."
}
},
"additionalProperties": false
}Check that an edit's old-string occurs exactly once in a file, with match contexts — Counts how many times an old-string occurs in a supplied file text (as a replace-in-file tool would see it) and returns each match's offset, line, column and surrounding lines, for an agent about to issue an edit. pass: exactly one literal match, even counting overlapping ones. unknown: several matches, or one match that overlaps another occurrence of the same text (ambiguous; contexts show how to
| Argument | Type | Description |
|---|---|---|
| file* | string | File text, at most 524288 UTF-8 bytes and 100000 lines. |
| oldString* | string | |
| contextLines | integer | Lines of context before and after each listed match. Default 2. |
{
"type": "object",
"required": [
"file",
"oldString"
],
"properties": {
"file": {
"type": "string",
"maxLength": 524288,
"description": "File text, at most 524288 UTF-8 bytes and 100000 lines."
},
"oldString": {
"type": "string",
"maxLength": 65536,
"minLength": 1
},
"contextLines": {
"type": "integer",
"maximum": 10,
"minimum": 0,
"description": "Lines of context before and after each listed match. Default 2."
}
},
"additionalProperties": false
}Check that every claim in an evidence bundle has enough independent, fresh, quote-verified support — Checks a bundle an agent assembled before answering: each claim must be backed by at least N evidence items from distinct source groups, each item's quote must actually appear in the supplied text (with offsets), publication dates must be within the caller's maximum age relative to a caller-supplied asOf, and duplicates are collapsed. Does not fetch URLs or judge whether a source is reliable or wh
| Argument | Type | Description |
|---|---|---|
| asOf | string | Reference instant (ISO 8601) for age checks; required with maxAgeDays. The check never reads the clock. |
| claims* | array | Claims to support. |
| evidence* | array | Up to 300 items; 300000 characters of text in total. |
| maxAgeDays | integer | Evidence published longer ago than this (relative to asOf) is stale. |
| requireQuotes | boolean | Evidence without a verifiable quote does not count as support. Default true. |
{
"type": "object",
"required": [
"claims",
"evidence"
],
"properties": {
"asOf": {
"type": "string",
"maxLength": 40,
"description": "Reference instant (ISO 8601) for age checks; required with maxAgeDays. The check never reads the clock."
},
"claims": {
"type": "array",
"items": {
"type": "object",
"required": [
"id"
],
"properties": {
"id": {
"type": "string",
"maxLength": 100,
"minLength": 1,
"description": "Unique id."
},
"text": {
"type": "string",
"maxLength": 2000
},
"minEvidence": {
"type": "integer",
"maximum": 20,
"minimum": 1,
"description": "Distinct source groups needed. Default 1."
}
},
"additionalProperties": false
},
"maxItems": 100,
"minItems": 1,
"description": "Claims to support."
},
"evidence": {
"type": "array",
"items": {
"type": "object",
"required": [
"id",
"claimIds"
],
"properties": {
"id": {
"type": "string",
"maxLength": 100,
"minLength": 1,
"description": "Unique id."
},
"url": {
"type": "string",
"maxLength": 2000
},
"text": {
"type": "string",
"maxLength": 50000,
"description": "Source text the quote should appear in."
},
"quote": {
"type": "string",
"maxLength": 2000,
"description": "Verbatim excerpt claimed from text."
},
"claimIds": {
"type": "array",
"items": {
"type": "string",
"maxLength": 100
},
"maxItems": 50,
"description": "Claims this item is offered for."
},
"publishedAt": {
"type": "string",
"maxLength": 40,
"description": "ISO 8601 date or date-time."
},
"sourceGroup": {
"type": "string",
"maxLength": 200,
"description": "Independent-source key (publisher/owner). Overrides the host reduction."
}
},
"additionalProperties": false
},
"maxItems": 300,
"description": "Up to 300 items; 300000 characters of text in total."
},
"maxAgeDays": {
"type": "integer",
"maximum": 36500,
"minimum": 0,
"description": "Evidence published longer ago than this (relative to asOf) is stale."
},
"requireQuotes": {
"type": "boolean",
"description": "Evidence without a verifiable quote does not count as support. Default true."
}
},
"additionalProperties": false
}Check that evidence covers the scope of the claim it is used for (geography, population, period, version, basis, unit) — Compares the scope descriptors of a claim and of the evidence offered for it, per dimension: geography and population (every claimed item must be equal to, or contained in a broader evidence item according to the caller's taxonomy), period (the evidence period must contain the claimed period; partial or no overlap is a mismatch), and version, basis and unit (must be equal after normalization). Des
| Argument | Type | Description |
|---|---|---|
| claim* | object | Scope of the claim being made. |
| evidence* | object | Scope of the evidence offered. |
| taxonomy | array | Containment facts for geography and population (40,000 characters in total), e.g. {broader:'United States', narrower:['California','Texas']}. Transitive. |
{
"type": "object",
"required": [
"claim",
"evidence"
],
"properties": {
"claim": {
"type": "object",
"properties": {
"unit": {
"type": "string",
"maxLength": 60,
"description": "Unit of measure."
},
"basis": {
"type": "string",
"maxLength": 100,
"description": "Measurement basis: per capita, nominal, mean, gross, as-reported..."
},
"period": {
"type": "object",
"required": [
"start",
"end"
],
"properties": {
"end": {
"type": "string",
"maxLength": 10,
"minLength": 4,
"description": "YYYY, YYYY-MM or YYYY-MM-DD, inclusive."
},
"start": {
"type": "string",
"maxLength": 10,
"minLength": 4,
"description": "YYYY, YYYY-MM or YYYY-MM-DD."
}
},
"additionalProperties": false
},
"version": {
"type": "string",
"maxLength": 60,
"description": "Software, standard or edition version."
},
"geography": {
"type": "array",
"items": {
"type": "string",
"maxLength": 100
},
"maxItems": 20,
"description": "Places the statement covers (countries, regions, 'worldwide')."
},
"population": {
"type": "array",
"items": {
"type": "string",
"maxLength": 100
},
"maxItems": 20,
"description": "Who/what is covered (adults, EU residents, Series A startups)."
}
},
"description": "Scope of the claim being made.",
"additionalProperties": false
},
"evidence": {
"type": "object",
"properties": {
"unit": {
"type": "string",
"maxLength": 60,
"description": "Unit of measure."
},
"basis": {
"type": "string",
"maxLength": 100,
"description": "Measurement basis: per capita, nominal, mean, gross, as-reported..."
},
"period": {
"type": "object",
"required": [
"start",
"end"
],
"properties": {
"end": {
"type": "string",
"maxLength": 10,
"minLength": 4,
"description": "YYYY, YYYY-MM or YYYY-MM-DD, inclusive."
},
"start": {
"type": "string",
"maxLength": 10,
"minLength": 4,
"description": "YYYY, YYYY-MM or YYYY-MM-DD."
}
},
"additionalProperties": false
},
"version": {
"type": "string",
"maxLength": 60,
"description": "Software, standard or edition version."
},
"geography": {
"type": "array",
"items": {
"type": "string",
"maxLength": 100
},
"maxItems": 20,
"description": "Places the statement covers (countries, regions, 'worldwide')."
},
"population": {
"type": "array",
"items": {
"type": "string",
"maxLength": 100
},
"maxItems": 20,
"description": "Who/what is covered (adults, EU residents, Series A startups)."
}
},
"description": "Scope of the evidence offered.",
"additionalProperties": false
},
"taxonomy": {
"type": "array",
"items": {
"type": "object",
"required": [
"broader",
"narrower"
],
"properties": {
"broader": {
"type": "string",
"maxLength": 100,
"minLength": 1
},
"narrower": {
"type": "array",
"items": {
"type": "string",
"maxLength": 100
},
"maxItems": 200
}
},
"additionalProperties": false
},
"maxItems": 100,
"description": "Containment facts for geography and population (40,000 characters in total), e.g. {broader:'United States', narrower:['California','Texas']}. Transitive."
}
},
"additionalProperties": false
}Fleet memory: your agents' shared observations of endpoints, rate limits, IVR paths and ambiguous submissions — Lets every agent in your fleet record what it observed and read what the others saw, with freshness: endpoint brownouts and latency, rate-limit behaviour, IVR menu paths that worked, whether an ambiguous submission was later accepted or rejected, fixes for an error signature, stale feeds, page recipes, merchant workflow failures, document reputation. record() appends timestamped observations for a
| Argument | Type | Description |
|---|---|---|
| op* | string | |
| subject* | string | What was observed, e.g. api.stripe.com:POST:/v1/refunds, +18005551234:billing, or an error fingerprint. |
| tenantId | string | Required for API-key callers (namespaced as key:<tenantId>; keep it unguessable). Ignored when a wallet paid: the payer address is the tenant. |
| namespace* | string | |
| requestId | string | Caller-chosen id for this mutation. A retry with the same id and same input returns the stored response (24 h) instead of applying twice; the same id with different input is rejected. Send one on every mutation you may retry: without it a retry is applied again (fleet-memory record appends a duplicate; a repeated spend-ledger commit or release answers NO_HOLD because the first call already took effect). |
| sinceHours | integer | query window; default 168 (7 days). |
Attach footnote texts to their in-text markers from page layout coordinates — Given footnote markers (label, page, x, y) and footnote texts (label, page, x, y) extracted from a laid-out document, pairs each marker with its note by label and page, pairing repeated labels on one page in reading order, optionally letting a note continue on the next page, and reports unattached markers, orphan notes, ambiguous groups (different counts for the same label) and notes placed above
| Argument | Type | Description |
|---|---|---|
| notes* | array | |
| yAxis | string | Direction of increasing y: down (PDF.js, screen) or up (PDF user space). Default down. |
| markers* | array | |
| allowNextPage | boolean | A note may sit on the page after its marker. Default false. |
{
"type": "object",
"required": [
"markers",
"notes"
],
"properties": {
"notes": {
"type": "array",
"items": {
"type": "object",
"required": [
"label",
"page",
"x",
"y",
"text"
],
"properties": {
"x": {
"type": "number",
"maximum": 1000000,
"minimum": -1000000
},
"y": {
"type": "number",
"maximum": 1000000,
"minimum": -1000000
},
"page": {
"type": "integer",
"maximum": 100000,
"minimum": 1
},
"text": {
"type": "string",
"maxLength": 5000
},
"label": {
"type": "string",
"maxLength": 20,
"minLength": 1,
"description": "Label as printed in the note."
}
},
"additionalProperties": false
},
"maxItems": 500
},
"yAxis": {
"enum": [
"down",
"up"
],
"type": "string",
"description": "Direction of increasing y: down (PDF.js, screen) or up (PDF user space). Default down."
},
"markers": {
"type": "array",
"items": {
"type": "object",
"required": [
"label",
"page",
"x",
"y"
],
"properties": {
"x": {
"type": "number",
"maximum": 1000000,
"minimum": -1000000
},
"y": {
"type": "number",
"maximum": 1000000,
"minimum": -1000000
},
"page": {
"type": "integer",
"maximum": 100000,
"minimum": 1
},
"text": {
"type": "string",
"maxLength": 200,
"description": "Context around the marker, echoed back."
},
"label": {
"type": "string",
"maxLength": 20,
"minLength": 1,
"description": "Marker as printed: 1, *, a."
}
},
"additionalProperties": false
},
"maxItems": 500
},
"allowNextPage": {
"type": "boolean",
"description": "A note may sit on the page after its marker. Default false."
}
},
"additionalProperties": false
}Signed hash receipt (Merkle batch, RFC 9162) — Timestamped, signed receipt for up to 256 SHA-256 hashes in one call: an RFC 9162 Merkle root, a per-hash inclusion proof, and the hub's W3C VC + EIP-191 signatures over both. For agents that need third-party evidence of what they did and when (action logs, generated files, prompts, tool outputs) without sending the data itself. Pure code, no model; verify free at /api/v1/verify-provenance.
| Argument | Type | Description |
|---|---|---|
| label | string | Optional caller label (run id, job id) included in the signed receipt. |
| hashes* | array | SHA-256 digests, 64 hex characters each. Hash your data locally; only the digests are sent. |
| proofs | boolean | Return an inclusion proof per hash. Default true. |
{
"type": "object",
"required": [
"hashes"
],
"properties": {
"label": {
"type": "string",
"maxLength": 200,
"description": "Optional caller label (run id, job id) included in the signed receipt."
},
"hashes": {
"type": "array",
"items": {
"type": "string",
"maxLength": 64,
"minLength": 64
},
"maxItems": 256,
"minItems": 1,
"description": "SHA-256 digests, 64 hex characters each. Hash your data locally; only the digests are sent."
},
"proofs": {
"type": "boolean",
"description": "Return an inclusion proof per hash. Default true."
}
},
"additionalProperties": false
}Extract hedging and certainty cues (may, probably, clearly, approximately) from text with offsets — Finds hedge and booster cues in an agent's or source's text using a fixed English lexicon (modals, epistemic verbs, adverbs and adjectives, approximators, shield phrases, certainty boosters) plus caller-supplied phrases, and returns each cue with its category, the sentence it sits in, and offsets in UTF-16, code points, UTF-8 bytes and graphemes. Rule-based and English only: a cue is a word match,
| Argument | Type | Description |
|---|---|---|
| text* | string | Text to scan. |
| extraCues | array | Caller cues added to the lexicon. |
{
"type": "object",
"required": [
"text"
],
"properties": {
"text": {
"type": "string",
"maxLength": 100000,
"minLength": 1,
"description": "Text to scan."
},
"extraCues": {
"type": "array",
"items": {
"type": "object",
"required": [
"phrase"
],
"properties": {
"phrase": {
"type": "string",
"maxLength": 80,
"minLength": 1,
"description": "Literal phrase, matched case-insensitively on word boundaries."
},
"polarity": {
"enum": [
"hedge",
"booster"
],
"type": "string"
}
},
"additionalProperties": false
},
"maxItems": 50,
"description": "Caller cues added to the lexicon."
}
},
"additionalProperties": false
}Classify an HTTP response as success, retry, reconcile or stop, with the wait it asks for — Classifies one HTTP response (method, status, headers) as success / retry / reconcile / stop for an agent that just called an API, and reads the wait from Retry-After (RFC 9110: delay-seconds or any of the three HTTP-date formats) or from a vendor delay header whose dialect the caller declares (seconds, milliseconds, epoch seconds, epoch milliseconds, HTTP-date). Caller-supplied vendor rules (stat
| Argument | Type | Description |
|---|---|---|
| asOf | string | RFC 3339 instant; needed to turn an HTTP-date or epoch delay into seconds. |
| method* | string | |
| status* | integer | |
| headers | array | Response headers as name/value pairs (names compared case-insensitively). |
| delayHeader | object | Which header carries the wait and in what dialect. Default is Retry-After under RFC 9110. |
| vendorRules | array | First matching rule wins. |
| idempotencyKey | object |
{
"type": "object",
"required": [
"method",
"status"
],
"properties": {
"asOf": {
"type": "string",
"maxLength": 40,
"description": "RFC 3339 instant; needed to turn an HTTP-date or epoch delay into seconds."
},
"method": {
"type": "string",
"maxLength": 32,
"minLength": 1
},
"status": {
"type": "integer",
"maximum": 599,
"minimum": 100
},
"headers": {
"type": "array",
"items": {
"type": "object",
"required": [
"name",
"value"
],
"properties": {
"name": {
"type": "string",
"maxLength": 100,
"minLength": 1
},
"value": {
"type": "string",
"maxLength": 1000
}
},
"additionalProperties": false
},
"maxItems": 100,
"description": "Response headers as name/value pairs (names compared case-insensitively)."
},
"delayHeader": {
"type": "object",
"required": [
"name",
"dialect"
],
"properties": {
"name": {
"type": "string",
"maxLength": 100,
"minLength": 1
},
"dialect": {
"enum": [
"retry-after",
"delay-seconds",
"delay-milliseconds",
"epoch-seconds",
"epoch-milliseconds",
"http-date"
],
"type": "string"
}
},
"description": "Which header carries the wait and in what dialect. Default is Retry-After under RFC 9110.",
"additionalProperties": false
},
"vendorRules": {
"type": "array",
"items": {
"type": "object",
"required": [
"outcome"
],
"properties": {
"note": {
"type": "string",
"maxLength": 300
},
"status": {
"type": "integer",
"maximum": 599,
"minimum": 100
},
"outcome": {
"enum": [
"success",
"retry",
"reconcile",
"stop"
],
"type": "string"
},
"statusMax": {
"type": "integer",
"maximum": 599,
"minimum": 100
},
"statusMin": {
"type": "integer",
"maximum": 599,
"minimum": 100
},
"headerName": {
"type": "string",
"maxLength": 100
},
"headerEquals": {
"type": "string",
"maxLength": 1000
}
},
"additionalProperties": false
},
"maxItems": 50,
"description": "First matching rule wins."
},
"idempotencyKey": {
"type": "object",
"required": [
"present"
],
"properties": {
"present": {
"type": "boolean"
},
"serverHonors": {
"enum": [
"yes",
"no",
"unknown"
],
"type": "string"
}
},
"additionalProperties": false
}
},
"additionalProperties": false
}Monotonic id blocks: the next invoice or ticket numbers for a fleet of agents — Hands out strictly increasing integer blocks from a named sequence (1-1000 ids per call) so parallel agents never issue the same invoice, ticket or order number. Numbers are never reused. Not gapless: a block an agent reserves and never uses stays a gap, and if your call's payment fails after the block is written the same requestId returns that same block on retry. Legally gapless series must be a
| Argument | Type | Description |
|---|---|---|
| op* | string | |
| count | integer | Ids to reserve; default 1. |
| start | integer | First id of a new sequence; ignored once it exists. Default 1. |
| sequence* | string | Sequence name, e.g. invoice:2026. |
| tenantId | string | Required for API-key callers (namespaced as key:<tenantId>; keep it unguessable). Ignored when a wallet paid: the payer address is the tenant. |
| requestId | string | Caller-chosen id for this mutation. A retry with the same id and same input returns the stored response (24 h) instead of applying twice; the same id with different input is rejected. Send one on every mutation you may retry: without it a retry is applied again (fleet-memory record appends a duplicate; a repeated spend-ledger commit or release answers NO_HOLD because the first call already took effect). |
Derive a stable idempotency fingerprint from declared identity fields and flag volatile fields — Hashes the fields you declare as the identity of an operation (JSON Pointers into each request) with RFC 8785 canonical JSON and SHA-256, so retries of the same operation get the same fingerprint regardless of key order, and flags the ways that breaks: an identity field missing, an identity field also declared volatile, identity values that look like timestamps, epoch times or UUIDs (heuristic), a
| Argument | Type | Description |
|---|---|---|
| scope | string | Mixed into the hash (for example operation name and tenant) so equal bodies in different scopes get different fingerprints. |
| identity* | array | JSON Pointers whose values define the operation's identity. |
| requests* | array | |
| volatile | array | JSON Pointers declared to change per attempt (timestamps, nonces, request ids). |
{
"type": "object",
"required": [
"requests",
"identity"
],
"properties": {
"scope": {
"type": "string",
"maxLength": 200,
"description": "Mixed into the hash (for example operation name and tenant) so equal bodies in different scopes get different fingerprints."
},
"identity": {
"type": "array",
"items": {
"type": "string",
"maxLength": 300
},
"maxItems": 50,
"minItems": 1,
"description": "JSON Pointers whose values define the operation's identity."
},
"requests": {
"type": "array",
"items": {
"description": "A request (body, or {method,url,body}) as JSON; several attempts of the same intended operation."
},
"maxItems": 20,
"minItems": 1
},
"volatile": {
"type": "array",
"items": {
"type": "string",
"maxLength": 300
},
"maxItems": 50,
"description": "JSON Pointers declared to change per attempt (timestamps, nonces, request ids)."
}
},
"additionalProperties": false
}Idempotency registry: has key K already been done? Claim it, complete it, read the stored result — Shared memory for side-effecting operations across agents and retries. begin(key) answers proceed (you hold a short claim), wait (another owner is mid-flight), already_completed (returns the stored result pointer), or fingerprint_mismatch (same key, different operation). complete(key) records the result pointer; abandon(key) lets someone retry. The claim expires, so a crashed worker does not block
| Argument | Type | Description |
|---|---|---|
| op* | string | |
| key* | string | Idempotency key, e.g. refund:ch_123:2026-11-04. |
| owner | string | Worker id; required for begin, complete and abandon. |
| result | object | complete: where the outcome lives (do not store payloads here). |
| tenantId | string | Required for API-key callers (namespaced as key:<tenantId>; keep it unguessable). Ignored when a wallet paid: the payer address is the tenant. |
| requestId | string | Caller-chosen id for this mutation. A retry with the same id and same input returns the stored response (24 h) instead of applying twice; the same id with different input is rejected. Send one on every mutation you may retry: without it a retry is applied again (fleet-memory record appends a duplicate; a repeated spend-ledger commit or release answers NO_HOLD because the first call already took effect). |
Receive-only inbox for agents without a public endpoint — Creates a receive-only inbox for an AI agent that has no public endpoint: a webhook URL that accepts POST or PUT, and (when the operator has configured inbound email) a unique email address. Pair with inbox-poll to read what arrived. It never sends email or calls out, does not store attachments, does not verify senders (no SPF/DKIM), and message content is untrusted third-party data. Inboxes live
| Argument | Type | Description |
|---|---|---|
| label | string | Optional name for your own bookkeeping. |
| tenantId | string | Required for API-key callers (namespace as key:<tenantId>; keep it unguessable). Ignored when a wallet paid. |
{
"type": "object",
"properties": {
"label": {
"type": "string",
"maxLength": 64,
"description": "Optional name for your own bookkeeping."
},
"tenantId": {
"type": "string",
"pattern": "^[A-Za-z0-9_.-]{1,64}$",
"description": "Required for API-key callers (namespace as key:<tenantId>; keep it unguessable). Ignored when a wallet paid."
}
},
"additionalProperties": false
}Read messages from a receive-only agent inbox — Returns the emails and webhook deliveries that arrived in an inbox you created with inbox-create, oldest first, with sender, subject, selected headers, a plain-text body (up to 64 KB per message in the response) and a sha256 of the stored body. Filter by since (inclusive), kind, limit up to 100; mark_consumed hides the returned messages from later polls unless include_consumed is true. It does not
| Argument | Type | Description |
|---|---|---|
| kind | string | Default all. |
| limit | integer | Default 50. |
| since | any | Only messages received at or after this time: epoch milliseconds or ISO 8601 (UTC when no offset). Inclusive, so dedupe by id or use mark_consumed. |
| inbox_id* | string | |
| tenantId | string | Required for API-key callers (namespace as key:<tenantId>; keep it unguessable). Ignored when a wallet paid. |
| mark_consumed | boolean | Mark the returned messages consumed. Default false. |
| include_consumed | boolean | Also return consumed messages. Default false. |
{
"type": "object",
"required": [
"inbox_id"
],
"properties": {
"kind": {
"enum": [
"all",
"email",
"webhook"
],
"type": "string",
"description": "Default all."
},
"limit": {
"type": "integer",
"maximum": 100,
"minimum": 1,
"description": "Default 50."
},
"since": {
"anyOf": [
{
"type": "integer",
"maximum": 8640000000000000,
"minimum": 0
},
{
"type": "string",
"maxLength": 40
}
],
"description": "Only messages received at or after this time: epoch milliseconds or ISO 8601 (UTC when no offset). Inclusive, so dedupe by id or use mark_consumed."
},
"inbox_id": {
"type": "string",
"pattern": "^[A-Za-z0-9_-]{1,64}$"
},
"tenantId": {
"type": "string",
"pattern": "^[A-Za-z0-9_.-]{1,64}$",
"description": "Required for API-key callers (namespace as key:<tenantId>; keep it unguessable). Ignored when a wallet paid."
},
"mark_consumed": {
"type": "boolean",
"description": "Mark the returned messages consumed. Default false."
},
"include_consumed": {
"type": "boolean",
"description": "Also return consumed messages. Default false."
}
},
"additionalProperties": false
}Label spans of a prompt as pasted data or instructions, and flag instruction-like text inside the data — Splits an agent's input into data regions (code fences, block quotes, XML-style wrappers such as <document>, BEGIN/END markers, triple quotes, email headers with body, JSON blocks) and the text around them, labels each sentence outside the data as instruction (leading imperative verb or polite request) or unknown, and lists injection-style phrases found anywhere in the text ('ignore previous instr
| Argument | Type | Description |
|---|---|---|
| text* | string | The full prompt or tool result to split. |
| dataTags | array | Extra XML-style tag names (letters, digits, underscore) whose content is data. |
{
"type": "object",
"required": [
"text"
],
"properties": {
"text": {
"type": "string",
"maxLength": 50000,
"minLength": 1,
"description": "The full prompt or tool result to split."
},
"dataTags": {
"type": "array",
"items": {
"type": "string",
"maxLength": 40
},
"maxItems": 20,
"description": "Extra XML-style tag names (letters, digits, underscore) whose content is data."
}
},
"additionalProperties": false
}Short lease with fencing tokens: claim a task for N seconds, renew, release — Lets many agents agree which one works on a task: acquire a named resource for 1-3600 s, renew it while working, release it when done. Every new acquisition returns a strictly larger fencing token; pass it to the downstream store and reject writes carrying a smaller one, so a paused holder whose lease expired cannot clobber its successor. Re-acquiring as the current holder extends the lease with t
| Argument | Type | Description |
|---|---|---|
| op* | string | |
| token | integer | Fencing token from acquire; required for renew and release. |
| holder | string | Your worker id. Required for acquire, renew and release. |
| resource* | string | Task or resource name, e.g. invoice:INV-1009 or deploy:prod. |
| tenantId | string | Required for API-key callers (namespaced as key:<tenantId>; keep it unguessable). Ignored when a wallet paid: the payer address is the tenant. |
| requestId | string | Caller-chosen id for this mutation. A retry with the same id and same input returns the stored response (24 h) instead of applying twice; the same id with different input is rejected. Send one on every mutation you may retry: without it a retry is applied again (fleet-memory record appends a duplicate; a repeated spend-ledger commit or release answers NO_HOLD because the first call already took effect). |
Detect LLM text watermark evidence: green-list z-test for a key you hold, plus invisible-character markers — Tests whether text carries watermark evidence, for a pipeline that must decide whether to trust or label content. Two independent checks: (1) a green-list z-test (Kirchenbauer et al. 2023) over green flags you supply, or over token ids and a key using this endpoint's own HMAC-SHA256 scheme, returning the z-score and exact binomial p-value; (2) an invisible-character scan of the text for zero-width
| Argument | Type | Description |
|---|---|---|
| key | string | Secret key for tokenIds. Used for this call only and never stored or echoed. |
| text | string | Text to scan for invisible markers. |
| gamma | number | Expected green fraction under no watermark. Default 0.25. |
| scheme | string | Scheme for tokenIds; default and only value. |
| tokenIds | array | Token ids in order (at most 5000). Green membership is computed from the key with the hmac-sha256-green-1 scheme; each distinct consecutive pair is scored once. |
| minTokens | integer | Fewer scored tokens than this is unknown. Default 25. |
| greenFlags | array | One 0/1 per scored token: 1 when your own detector's green list contains the token. Deduplicate repeated n-grams yourself if your scheme requires it. |
Collapse a log into error signatures with counts and first/last occurrence — Groups the records of a log or CI output by signature: timestamps, UUIDs, IPs, hex ids, quoted values and numbers are replaced by placeholders, stack-trace continuation lines are attached to their record and contribute their first frames, and each signature reports its count, severity, first and last line, first and last timestamp (as written, when the line starts with an ISO 8601 timestamp) and a
| Argument | Type | Description |
|---|---|---|
| text* | string | Log text, at most 8000 lines. |
| topN | integer | Signatures returned, by count. Default 20. |
| minSeverity | string | Ignore records below this severity. Default: keep all. |
| signatureFrames | integer | Continuation lines (stack frames) that are part of the signature. Default 3. |
{
"type": "object",
"required": [
"text"
],
"properties": {
"text": {
"type": "string",
"maxLength": 300000,
"minLength": 1,
"description": "Log text, at most 8000 lines."
},
"topN": {
"type": "integer",
"maximum": 100,
"minimum": 1,
"description": "Signatures returned, by count. Default 20."
},
"minSeverity": {
"enum": [
"fatal",
"error",
"warn",
"info",
"debug",
"trace",
"unknown"
],
"type": "string",
"description": "Ignore records below this severity. Default: keep all."
},
"signatureFrames": {
"type": "integer",
"maximum": 10,
"minimum": 0,
"description": "Continuation lines (stack frames) that are part of the signature. Default 3."
}
},
"additionalProperties": false
}Normalize sloppy model-generated Markdown to one house style, leaving code untouched — Rewrites Markdown from a language model into a consistent style and reports each edit by line: restores the space in '##Title', converts '*', '+' and '•' bullets to your chosen marker, strips trailing whitespace (keeping two-space hard breaks), collapses runs of blank lines, puts blank lines around headings and fenced blocks, closes a fence left open at the end, and ends the file with one newline.
| Argument | Type | Description |
|---|---|---|
| bullet | string | Marker for unordered lists. Default '-'. |
| markdown* | string | Markdown to normalize. |
| finalNewline | boolean | End with exactly one newline. Default true. |
| fixHeadingSpace | boolean | Restore the space in '##Title'. A lowercase '#tag' at level 1 is treated as a hashtag and left alone. Default true. |
| closeUnclosedFence | boolean | Append the closing fence when the document ends inside one. Default true. |
| collapseBlankLines | boolean | Collapse runs of blank lines and drop leading and trailing blanks. Default true. |
| blankLinesAroundBlocks | boolean | Insert a blank line around headings and top-level fenced blocks. Default true. |
MCP tool pin: detect changed tool definitions (rug pulls) and hidden Unicode — Send an MCP server's tools/list result (up to 200 tools) and, after the first call, the hashes you approved. Returns a reproducible manifest hash, a per-tool hash, which tools were added, removed or changed since approval (silent description and schema edits are how MCP rug pulls and tool poisoning land), and Unicode smuggling findings in every name, description and schema string. Call it at sessi
| Argument | Type | Description |
|---|---|---|
| tools* | array | The tools array from an MCP tools/list response, as received. |
| approvedTools | object | Map of tool name to the per-tool hash you approved; enables the added/removed/changed diff. |
| approvedManifestHash | string | manifestHash from the call you approved. |
{
"type": "object",
"required": [
"tools"
],
"properties": {
"tools": {
"type": "array",
"items": {
"type": "object",
"required": [
"name"
],
"properties": {
"name": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"annotations": {
"type": "object"
},
"description": {
"type": "string",
"maxLength": 20000
},
"inputSchema": {
"type": "object"
},
"outputSchema": {
"type": "object"
}
}
},
"maxItems": 200,
"minItems": 1,
"description": "The tools array from an MCP tools/list response, as received."
},
"approvedTools": {
"type": "object",
"description": "Map of tool name to the per-tool hash you approved; enables the added/removed/changed diff."
},
"approvedManifestHash": {
"type": "string",
"maxLength": 64,
"minLength": 64,
"description": "manifestHash from the call you approved."
}
},
"additionalProperties": false
}Run up to 20 micro checks under one payment ($0.02) — Bundles up to 20 calls to any pure micro check (catalog entries that are neither stateful nor network-reading, e.g. checksum, patch-anchor, allocate, business-deadline) into one x402 settlement, so a full batch costs $0.001 per check. Every call is validated before payment; one invalid call rejects the batch with its index. The request is capped at 128kb and a CPU weight of 40 (an ordinary check w
| Argument | Type | Description |
|---|---|---|
| calls* | array |
{
"type": "object",
"required": [
"calls"
],
"properties": {
"calls": {
"type": "array",
"items": {
"type": "object",
"required": [
"tool",
"input"
],
"properties": {
"tool": {
"type": "string",
"pattern": "^[a-z0-9]+(-[a-z0-9]+)*$",
"description": "Micro check id, e.g. checksum."
},
"input": {
"type": "object",
"description": "That check's own request body."
}
},
"additionalProperties": false
},
"maxItems": 20,
"minItems": 1
}
},
"additionalProperties": false
}Diff a before/after JSON write for deletes, null-vs-omit and emptied arrays against protected paths — Compares the JSON document an agent read (before) with the one it is about to write (after) and lists every change by JSON Pointer: removed members, null turned into omitted (and the reverse), arrays emptied or shrunk, objects emptied, type changes. Fails when a change touches a protected path or is destructive and not listed in allowDestructive; use it before a PUT, PATCH or bulk update. Arrays a
| Argument | Type | Description |
|---|---|---|
| after* | any | JSON value about to be written. |
| before* | any | JSON value as last read. |
| protectedPaths | array | JSON Pointers that must not change at all; a "*" token matches any one key or index. |
| allowDestructive | array | JSON Pointers ("*" wildcard) under which deletes, emptied containers and type changes are intended. |
{
"type": "object",
"required": [
"before",
"after"
],
"properties": {
"after": {
"description": "JSON value about to be written."
},
"before": {
"description": "JSON value as last read."
},
"protectedPaths": {
"type": "array",
"items": {
"type": "string",
"maxLength": 300
},
"maxItems": 100,
"description": "JSON Pointers that must not change at all; a \"*\" token matches any one key or index."
},
"allowDestructive": {
"type": "array",
"items": {
"type": "string",
"maxLength": 300
},
"maxItems": 100,
"description": "JSON Pointers (\"*\" wildcard) under which deletes, emptied containers and type changes are intended."
}
},
"additionalProperties": false
}Find negation cues and the words they cover; report whether given terms fall inside a negation scope — Applies NegEx-style rules (the English termset of negspacy, MIT, derived from NegEx) to text: finds negation cues, pseudo-negations such as 'not only', and scope terminators such as 'but', and returns each cue's scope window with offsets in UTF-16, code points, UTF-8 bytes and graphemes. Given target terms, reports per occurrence whether it is negated, not negated by the rules, or unknown (near a
| Argument | Type | Description |
|---|---|---|
| text* | string | Text to analyze. |
| window | integer | Words a cue covers (NegEx uses 5). Default 5. |
| targets | array | Terms to classify (literal, case-insensitive, whole words). |
{
"type": "object",
"required": [
"text"
],
"properties": {
"text": {
"type": "string",
"maxLength": 50000,
"minLength": 1,
"description": "Text to analyze."
},
"window": {
"type": "integer",
"maximum": 20,
"minimum": 1,
"description": "Words a cue covers (NegEx uses 5). Default 5."
},
"targets": {
"type": "array",
"items": {
"type": "string",
"maxLength": 100
},
"maxItems": 50,
"description": "Terms to classify (literal, case-insensitive, whole words)."
}
},
"additionalProperties": false
}Plot a prose intensity curve per sentence and flag where a tense passage loses velocity — Scores each sentence of narrative prose for pace from sentence length, share of one-syllable words, exclamation and question marks and, if you supply a word list, action-word share; smooths the scores into an intensity curve; and reports stalls, the spans where intensity falls well below an earlier peak. For a writing tool or editor agent checking an action or tension scene. A fixed-weight heurist
| Argument | Type | Description |
|---|---|---|
| text* | string | Prose to score. |
| expect | string | tense: fail if the curve never reaches peakThreshold. any (default): only stalls after a peak can fail. |
| window | integer | Sentences in the trailing moving average. Default 3. |
| stallDrop | number | Fall below the running peak that counts as a stall. Default 0.25 on the 0-1 intensity scale. |
| actionWords | array | Your own action-word list. Without it the action component is left out and the other weights are renormalized. |
| minSentences | integer | Fewer scored sentences is unknown. Default 8. |
| peakThreshold | number | Smoothed intensity a passage must reach before a later fall can be a stall. Default 0.55. |
Detect repeated cursors, duplicate-only pages and no progress in a pagination scan — Takes the pages an agent has fetched so far (cursor used, next cursor returned, item ids) and finds the failures that make a scan loop or lie: a next cursor already used, a page whose items were all seen before, a page that returned nothing new yet offers another cursor, a scan that has not ended. Optionally takes declared ordering and cursor assumptions and lists the omission risks they imply (of
| Argument | Type | Description |
|---|---|---|
| pages* | array | |
| declared | object |
{
"type": "object",
"required": [
"pages"
],
"properties": {
"pages": {
"type": "array",
"items": {
"type": "object",
"required": [
"items"
],
"properties": {
"items": {
"type": "array",
"items": {
"type": "string",
"maxLength": 200
},
"maxItems": 2000,
"description": "Stable item ids on this page, in returned order."
},
"cursor": {
"type": "string",
"maxLength": 500,
"description": "Cursor used to request this page; omit for the first page."
},
"nextCursor": {
"type": "string",
"maxLength": 500,
"description": "Cursor returned for the next page; omit or empty when the API reports no more."
}
},
"additionalProperties": false
},
"maxItems": 500,
"minItems": 1
},
"declared": {
"type": "object",
"properties": {
"ordering": {
"enum": [
"stable-unique-key",
"stable-nonunique-key",
"unstable",
"unknown"
],
"type": "string",
"description": "How the API orders results."
},
"cursorKind": {
"enum": [
"opaque",
"offset",
"keyset"
],
"type": "string"
},
"mutatedDuringScan": {
"type": "boolean",
"description": "Whether items may have been inserted or deleted while paging."
}
},
"additionalProperties": false
}
},
"additionalProperties": false
}Apply a unified-diff hunk or search/replace edit to a file by content, refusing ambiguity — Applies unified-diff hunks (wrong line numbers are fine) or search/replace blocks to a supplied file text and returns the patched text, for an agent whose edit tool failed or whose diff has drifted line numbers. Each hunk is located by its content against the original file, trying exact, trailing-whitespace, outer-whitespace then collapsed-whitespace matching; the rung used is reported per hunk. I
| Argument | Type | Description |
|---|---|---|
| diff | string | Single-file unified diff, at most 64 hunks and 400 anchor lines each. Header counts and line numbers are ignored except as a reported hint. Give either diff or edits. |
| file* | string | Current file text, at most 524288 UTF-8 bytes and 100000 lines. A leading BOM is preserved. |
| edits | array | Search/replace blocks, matched as whole lines against the original file; all are located before any is applied. |
{
"type": "object",
"required": [
"file"
],
"properties": {
"diff": {
"type": "string",
"maxLength": 262144,
"description": "Single-file unified diff, at most 64 hunks and 400 anchor lines each. Header counts and line numbers are ignored except as a reported hint. Give either diff or edits."
},
"file": {
"type": "string",
"maxLength": 524288,
"description": "Current file text, at most 524288 UTF-8 bytes and 100000 lines. A leading BOM is preserved."
},
"edits": {
"type": "array",
"items": {
"type": "object",
"required": [
"search",
"replace"
],
"properties": {
"line": {
"type": "integer",
"maximum": 1000000,
"minimum": 1,
"description": "Optional line hint, reported as lineShift and never used to break ties."
},
"search": {
"type": "string",
"maxLength": 65536
},
"replace": {
"type": "string",
"maxLength": 65536,
"description": "Empty string deletes the matched lines."
}
},
"additionalProperties": false
},
"maxItems": 64,
"minItems": 1,
"description": "Search/replace blocks, matched as whole lines against the original file; all are located before any is applied."
}
},
"additionalProperties": false
}Effective permissions of a delegated agent: requested ∩ user ∩ parent, minus explicit denials — Computes what a sub-agent may actually do: the permissions it requested, intersected with what the end user holds and what its parent agent holds, minus any explicit deny list, and says for each denied permission which party lacks it. Permission names are compared exactly (no wildcards); caller-declared implications (for example 'admin' grants 'read') can be given and are expanded transitively wit
| Argument | Type | Description |
|---|---|---|
| user* | array | Permissions held by the end user. |
| denied | array | Explicit denials; they win over any grant. |
| parent* | array | Permissions held by the delegating agent. |
| implies | array | |
| requested* | array | Permissions the delegate asks for. |
{
"type": "object",
"required": [
"requested",
"user",
"parent"
],
"properties": {
"user": {
"type": "array",
"items": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"maxItems": 300,
"description": "Permissions held by the end user."
},
"denied": {
"type": "array",
"items": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"maxItems": 300,
"description": "Explicit denials; they win over any grant."
},
"parent": {
"type": "array",
"items": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"maxItems": 300,
"description": "Permissions held by the delegating agent."
},
"implies": {
"type": "array",
"items": {
"type": "object",
"required": [
"permission",
"grants"
],
"properties": {
"grants": {
"type": "array",
"items": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"maxItems": 50,
"minItems": 1
},
"permission": {
"type": "string",
"maxLength": 200,
"minLength": 1
}
},
"additionalProperties": false
},
"maxItems": 100
},
"requested": {
"type": "array",
"items": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"maxItems": 300,
"minItems": 1,
"description": "Permissions the delegate asks for."
}
},
"additionalProperties": false
}Policy gate with a signed receipt: your JsonLogic rules vs a proposed tool call or payment — Evaluates your own policy (JsonLogic rules, each allow or deny, deny-overrides or first-match, default deny) against a proposed tool call, payment or action, and returns allow or deny, the rule id that decided, and a receipt signed by the hub over the hashes of the policy, the request and the decision. The receipt is the product: another agent or an auditor can verify offline which rule allowed th
| Argument | Type | Description |
|---|---|---|
| policy* | any | JsonLogic: { rules: [{ id, effect: allow|deny, when: <JsonLogic>, description? }] (at most 100), combining?: deny-overrides|first-match, defaultEffect?: deny|allow }. A string for cedar/rego. |
| request* | any | The proposed action as JSON (at most 65536 bytes), e.g. { tool, args, amountUsd, payee }. Rules read it with { "var": "args.amountUsd" }. |
| language | string | Default jsonlogic. cedar and rego return unsupported. |
{
"type": "object",
"required": [
"policy",
"request"
],
"properties": {
"policy": {
"description": "JsonLogic: { rules: [{ id, effect: allow|deny, when: <JsonLogic>, description? }] (at most 100), combining?: deny-overrides|first-match, defaultEffect?: deny|allow }. A string for cedar/rego."
},
"request": {
"description": "The proposed action as JSON (at most 65536 bytes), e.g. { tool, args, amountUsd, payee }. Rules read it with { \"var\": \"args.amountUsd\" }."
},
"language": {
"enum": [
"jsonlogic",
"cedar",
"rego"
],
"type": "string",
"description": "Default jsonlogic. cedar and rego return unsupported."
}
},
"additionalProperties": false
}Would this request fit in the remaining quota, given a snapshot and pending reservations? (snapshot-bound) — Computes available quota from a caller-supplied snapshot (limit, used, reserved) minus the unexpired pending reservations and says whether a requested amount fits. This is a read of the numbers you supply as of snapshotAt: it reserves nothing, so concurrent consumers can still use the quota before you do, and every response says so. A stale snapshot gives unknown, not pass; a window that ended at
| Argument | Type | Description |
|---|---|---|
| asOf* | string | RFC 3339 instant of the decision (no clock is read). |
| quota* | object | |
| pending | array | |
| request* | object | |
| snapshotAt* | string | RFC 3339 instant the quota numbers were read. |
| maxSnapshotAgeSeconds | integer |
{
"type": "object",
"required": [
"quota",
"request",
"snapshotAt",
"asOf"
],
"properties": {
"asOf": {
"type": "string",
"maxLength": 40,
"description": "RFC 3339 instant of the decision (no clock is read)."
},
"quota": {
"type": "object",
"required": [
"limit",
"used"
],
"properties": {
"used": {
"type": "integer",
"maximum": 9007199254740991,
"minimum": 0
},
"limit": {
"type": "integer",
"maximum": 9007199254740991,
"minimum": 0
},
"reserved": {
"type": "integer",
"maximum": 9007199254740991,
"minimum": 0,
"description": "Amount already reserved and counted outside `pending`."
},
"windowEndsAt": {
"type": "string",
"maxLength": 40,
"description": "RFC 3339 end of the quota window the snapshot belongs to."
}
},
"additionalProperties": false
},
"pending": {
"type": "array",
"items": {
"type": "object",
"required": [
"id",
"amount"
],
"properties": {
"id": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"amount": {
"type": "integer",
"maximum": 9007199254740991,
"minimum": 0
},
"expiresAt": {
"type": "string",
"maxLength": 40,
"description": "RFC 3339; a reservation expiring at or before asOf no longer holds quota. Omit for a hold that does not expire."
}
},
"additionalProperties": false
},
"maxItems": 200
},
"request": {
"type": "object",
"required": [
"amount"
],
"properties": {
"amount": {
"type": "integer",
"maximum": 9007199254740991,
"minimum": 0
}
},
"additionalProperties": false
},
"snapshotAt": {
"type": "string",
"maxLength": 40,
"description": "RFC 3339 instant the quota numbers were read."
},
"maxSnapshotAgeSeconds": {
"type": "integer",
"maximum": 31536000,
"minimum": 0
}
},
"additionalProperties": false
}Content-addressed result cache shared by your agents (short TTL) — Caches a result under the SHA-256 of the canonical (JCS) request, so every agent in your fleet that makes the same request reuses one answer for up to an hour. get returns hit with the value and age, or a miss (status unknown). Scoped to your wallet or tenantId, never shared across customers, so nobody else can poison your cache.
| Argument | Type | Description |
|---|---|---|
| op* | string | |
| value | any | put: the JSON result, at most 16384 bytes serialized. |
| request* | any | Any JSON identifying the computation; it is canonicalized (RFC 8785) and hashed. |
| tenantId | string | Required for API-key callers (namespaced as key:<tenantId>; keep it unguessable). Ignored when a wallet paid: the payer address is the tenant. |
| namespace | string | Default: default. |
| ttlSeconds | integer | put: default 300. |
{
"type": "object",
"required": [
"op",
"request"
],
"properties": {
"op": {
"enum": [
"get",
"put"
],
"type": "string"
},
"value": {
"description": "put: the JSON result, at most 16384 bytes serialized."
},
"request": {
"description": "Any JSON identifying the computation; it is canonicalized (RFC 8785) and hashed."
},
"tenantId": {
"type": "string",
"pattern": "^[A-Za-z0-9_.-]{1,64}$",
"description": "Required for API-key callers (namespaced as key:<tenantId>; keep it unguessable). Ignored when a wallet paid: the payer address is the tenant."
},
"namespace": {
"type": "string",
"pattern": "^[A-Za-z0-9_.:-]{1,64}$",
"description": "Default: default."
},
"ttlSeconds": {
"type": "integer",
"maximum": 3600,
"minimum": 1,
"description": "put: default 300."
}
},
"additionalProperties": false
}Decide whether a failed HTTP call may be retried, must be reconciled, or must not be repeated — Given a request's method, how it ended (response status, timeout, reset, refused), idempotency-key evidence and optional caller policy, returns retry / do-not-retry / reconcile / unknown for an agent deciding what to do after a failed tool or API call. Encodes RFC 9110 method idempotency, the proxy and retry-of-a-retry rules and Retry-After parsing; a timeout or reset is never read as success or a
| Argument | Type | Description |
|---|---|---|
| asOf | string | RFC 3339 instant; needed only to turn a Retry-After HTTP-date into seconds. |
| actor | string | |
| ended* | string | How the attempt ended. |
| method* | string | HTTP method, case-sensitive (GET, POST, ...). |
| policy | object | |
| status | integer | Required when ended is 'response'. |
| attempt | integer | 1-based number of the attempt that just ended. Default 1. |
| automatic | boolean | True when the retry would be issued automatically (library or proxy) rather than by a deliberate decision. |
Spend ledger with reservations: one budget for a tree of agents — A budget shared by a task tree, in integer minor units. reserve() atomically holds an amount if the remaining budget covers it (expired holds are freed automatically); commit() records what was actually spent, up to the hold; release() frees a hold. These are real reservations, not a snapshot: two workers cannot both reserve the last dollar. It records spending; it does not move money.
| Argument | Type | Description |
|---|---|---|
| op* | string | |
| ledger* | string | Ledger name, e.g. task:research-42. |
| currency | string | open: currency or token code, e.g. USD or USDC. |
| tenantId | string | Required for API-key callers (namespaced as key:<tenantId>; keep it unguessable). Ignored when a wallet paid: the payer address is the tenant. |
| requestId | string | Caller-chosen id for this mutation. A retry with the same id and same input returns the stored response (24 h) instead of applying twice; the same id with different input is rejected. Send one on every mutation you may retry: without it a retry is applied again (fleet-memory record appends a duplicate; a repeated spend-ledger commit or release answers NO_HOLD because the first call already took effect). |
| ttlSeconds | integer | reserve: hold lifetime; default 600. |
| amountMinor |
Detect near-duplicate passages (syndicated or copied text) so repeated sources are not counted as independent — Compares up to 30 passages an agent collected and reports which pairs share word-shingle content (Jaccard and containment), grouping them into clusters of probable copies so the number of independent sources can be stated honestly. Does not establish who copied whom, does not detect paraphrase or translation, and does not fetch anything; a high similarity is a hint that sources are not independent
| Argument | Type | Description |
|---|---|---|
| passages* | array | Up to 30; 300000 characters in total. |
| shingleWords | integer | Words per shingle. Default 5. |
| jaccardThreshold | number | Pairs at or above this Jaccard similarity are flagged. Default 0.5. |
| containmentThreshold | number | Pairs where this share of the smaller passage's shingles appear in the other are flagged (catches an excerpt of a longer copy). Default 0.8. |
{
"type": "object",
"required": [
"passages"
],
"properties": {
"passages": {
"type": "array",
"items": {
"type": "object",
"required": [
"id",
"text"
],
"properties": {
"id": {
"type": "string",
"maxLength": 100,
"minLength": 1,
"description": "Unique id."
},
"url": {
"type": "string",
"maxLength": 2000
},
"text": {
"type": "string",
"maxLength": 50000,
"minLength": 1,
"description": "Passage text."
}
},
"additionalProperties": false
},
"maxItems": 30,
"minItems": 2,
"description": "Up to 30; 300000 characters in total."
},
"shingleWords": {
"type": "integer",
"maximum": 12,
"minimum": 2,
"description": "Words per shingle. Default 5."
},
"jaccardThreshold": {
"type": "number",
"maximum": 1,
"minimum": 0.05,
"description": "Pairs at or above this Jaccard similarity are flagged. Default 0.5."
},
"containmentThreshold": {
"type": "number",
"maximum": 1,
"minimum": 0.05,
"description": "Pairs where this share of the smaller passage's shingles appear in the other are flagged (catches an excerpt of a longer copy). Default 0.8."
}
},
"additionalProperties": false
}Interpret a test run: pass, no-tests, skipped, flaky, infra-failure from runner, exit code and counts — Reads a finished test run (runner, exit code, optional version, flags, caller-parsed counts, optional go test output, optional per-attempt exit codes) and says whether tests actually passed, ran nothing, were all skipped, passed only on retry, or never ran properly (timeout, signal, internal error). Encodes only exit-code semantics the runners document: pytest 0-5, node:test, mocha (failure count
| Argument | Type | Description |
|---|---|---|
| flags | object | |
| counts | object | Counts parsed by the caller from the runner's own report. |
| output | string | go test output (only ok, FAIL, --- FAIL and panic: lines are read). |
| runner* | string | |
| signal | string | Terminating signal name, e.g. SIGKILL. |
| version | string | Runner version, e.g. 10.4.0. Needed only for version-gated flags. |
| exitCode | integer | Process exit status. Omit when the process was killed by a signal or timed out. |
| timedOut | boolean | True when the harness gave up waiting. |
Convert text offsets between UTF-16, code points, UTF-8 bytes and graphemes, and locate hidden Unicode — Reports the length of a string in UTF-16 code units, Unicode code points, UTF-8 bytes and extended grapheme clusters (Intl.Segmenter), converts up to 200 ranges given in any one of those units into all four, and flags ranges that fall inside a surrogate pair, a multi-byte UTF-8 character or a grapheme cluster. It also runs the unicode-check rules (bidi controls, zero-width and invisible characters
| Argument | Type | Description |
|---|---|---|
| kind | string | How the unicode rules treat the string. Default text. |
| scan | boolean | Run the hidden-Unicode rules. Default true. |
| text* | string | The string. |
| ranges | array | Half-open ranges to convert; each is read in its own unit. |
{
"type": "object",
"required": [
"text"
],
"properties": {
"kind": {
"enum": [
"text",
"identifier",
"url"
],
"type": "string",
"description": "How the unicode rules treat the string. Default text."
},
"scan": {
"type": "boolean",
"description": "Run the hidden-Unicode rules. Default true."
},
"text": {
"type": "string",
"maxLength": 50000,
"minLength": 0,
"description": "The string."
},
"ranges": {
"type": "array",
"items": {
"type": "object",
"required": [
"unit",
"start",
"end"
],
"properties": {
"end": {
"type": "integer",
"maximum": 10000000,
"minimum": 0
},
"unit": {
"enum": [
"utf16",
"codePoint",
"utf8",
"grapheme"
],
"type": "string"
},
"start": {
"type": "integer",
"maximum": 10000000,
"minimum": 0
}
},
"additionalProperties": false
},
"maxItems": 200,
"description": "Half-open ranges to convert; each is read in its own unit."
}
},
"additionalProperties": false
}Shared token bucket: many agents, one upstream rate limit — One rate limiter shared by every agent in your fleet. take(cost) atomically spends tokens if available and returns allowed plus remaining, or refuses with retryAfterMs until enough tokens refill. capacity and refillPerSecond are fixed when the bucket is first used; a call with different settings is refused so two fleets cannot silently disagree. Use a requestId so a retried take is not charged twi
| Argument | Type | Description |
|---|---|---|
| op* | string | |
| cost | number | Tokens to spend; default 1. |
| bucket* | string | Bucket name, e.g. openai:org-123:rpm. |
| capacity* | number | |
| tenantId | string | Required for API-key callers (namespaced as key:<tenantId>; keep it unguessable). Ignored when a wallet paid: the payer address is the tenant. |
| requestId | string | Caller-chosen id for this mutation. A retry with the same id and same input returns the stored response (24 h) instead of applying twice; the same id with different input is rejected. Send one on every mutation you may retry: without it a retry is applied again (fleet-memory record appends a duplicate; a repeated spend-ledger commit or release answers NO_HOLD because the first call already took effect). |
| refillPerSecond |
Check tool-call / tool-result pairing and ordering in an LLM transcript (Anthropic, OpenAI Chat, OpenAI Responses) — Validates a message list before it is sent to Anthropic Messages, OpenAI Chat Completions or OpenAI Responses: every tool call paired with its result, results in the right place and role, ids present and unique. Built for an agent that edits, truncates or replays its own history and would otherwise get a 400. Only rules stated in the providers' documentation fail the check; anything else suspiciou
| Argument | Type | Description |
|---|---|---|
| messages* | array | |
| provider* | string | |
| expectComplete | boolean | Default true: a trailing tool call without a result is a defect. Set false when the transcript is mid-loop and results are still pending. |
{
"type": "object",
"required": [
"provider",
"messages"
],
"properties": {
"messages": {
"type": "array",
"items": {
"description": "A provider-shaped message (anthropic, openai-chat) or input item (openai-responses)."
},
"maxItems": 500,
"minItems": 1
},
"provider": {
"enum": [
"anthropic",
"openai-chat",
"openai-responses"
],
"type": "string"
},
"expectComplete": {
"type": "boolean",
"description": "Default true: a trailing tool call without a result is a defect. Set false when the transcript is mid-loop and results are still pending."
}
},
"additionalProperties": false
}Check that numbers, units, part numbers, tolerance signs, dates, placeholders and URLs survive translation — For aligned source and target segments, extracts the tokens a translation must not change (numbers with attached units or %, ISO dates, part numbers and versions, tolerance and comparison operators such as ± ≤ ≥, placeholders like {0} or %s, URLs and emails) and reports any that are missing, added or altered, with offsets in both texts in UTF-16, code points, UTF-8 bytes and graphemes. Numbers are
| Argument | Type | Description |
|---|---|---|
| kinds | array | Token kinds to check. Default all. |
| segments* | array | Up to 200; 100000 characters in total. |
| sourceDecimal | string | Decimal mark of the source locale. Default auto (both readings tried). |
| targetDecimal | string | Decimal mark of the target locale. Default auto. |
{
"type": "object",
"required": [
"segments"
],
"properties": {
"kinds": {
"type": "array",
"items": {
"enum": [
"number",
"identifier",
"operator",
"placeholder",
"url",
"date"
],
"type": "string"
},
"maxItems": 6,
"description": "Token kinds to check. Default all."
},
"segments": {
"type": "array",
"items": {
"type": "object",
"required": [
"id",
"source",
"target"
],
"properties": {
"id": {
"type": "string",
"maxLength": 100,
"minLength": 1,
"description": "Echoed back."
},
"source": {
"type": "string",
"maxLength": 10000
},
"target": {
"type": "string",
"maxLength": 10000
}
},
"additionalProperties": false
},
"maxItems": 200,
"minItems": 1,
"description": "Up to 200; 100000 characters in total."
},
"sourceDecimal": {
"enum": [
".",
",",
"auto"
],
"type": "string",
"description": "Decimal mark of the source locale. Default auto (both readings tried)."
},
"targetDecimal": {
"enum": [
".",
",",
"auto"
],
"type": "string",
"description": "Decimal mark of the target locale. Default auto."
}
},
"additionalProperties": false
}Unicode smuggling check for strings (prompts, tool args, URLs) — Checks up to 100 strings in one call against the 19 deterministic rules of unicode-safety-check: bidi controls (Trojan Source), invisible and zero-width characters, tag-character and variation-selector payloads, homoglyph and mixed-script hosts or names. Built for an agent's hot path: run it on a prompt, a tool argument, a URL or a model output before acting on it. Returns BLOCK / REVIEW / NO_FIND
| Argument | Type | Description |
|---|---|---|
| kind | string | text (default): prose, only critical findings block. identifier or url: high findings such as mixed-script names also block. |
| strings* | array | Up to 200000 characters in total. |
{
"type": "object",
"required": [
"strings"
],
"properties": {
"kind": {
"enum": [
"text",
"identifier",
"url"
],
"type": "string",
"description": "text (default): prose, only critical findings block. identifier or url: high findings such as mixed-script names also block."
},
"strings": {
"type": "array",
"items": {
"type": "string",
"maxLength": 10000
},
"maxItems": 100,
"minItems": 1,
"description": "Up to 200000 characters in total."
}
},
"additionalProperties": false
}What do omitted, null, [] and "" mean in this PATCH body under merge-patch, JSON Patch or a declared dialect? — For an agent about to send a PATCH or update body: states, per field, what omitted / null / [] / "" mean under the declared dialect (RFC 7396 merge patch, RFC 6902 JSON Patch, or caller-declared semantics) and checks the body against stated intents such as 'clear this field', 'leave this alone' or 'set to empty array'. With a target document it applies the patch and compares the result; without on
| Argument | Type | Description |
|---|---|---|
| target | any | Current document, if available. Enables applying the patch and exact checks. |
| dialect* | string | merge-patch = RFC 7396, json-patch = RFC 6902 (payload is an array of operations), caller = semantics in callerSemantics. |
| intents | array | |
| payload* | any | The PATCH body. |
| callerSemantics | object | Required when dialect is 'caller': what each payload form means in that API. |
{
"type": "object",
"required": [
"dialect",
"payload"
],
"properties": {
"target": {
"description": "Current document, if available. Enables applying the patch and exact checks."
},
"dialect": {
"enum": [
"merge-patch",
"json-patch",
"caller"
],
"type": "string",
"description": "merge-patch = RFC 7396, json-patch = RFC 6902 (payload is an array of operations), caller = semantics in callerSemantics."
},
"intents": {
"type": "array",
"items": {
"type": "object",
"required": [
"path",
"expect"
],
"properties": {
"path": {
"type": "string",
"maxLength": 300,
"description": "JSON Pointer into the document."
},
"value": {
"description": "Required when expect is 'value'."
},
"expect": {
"enum": [
"unchanged",
"absent",
"null",
"empty-array",
"empty-string",
"value"
],
"type": "string"
}
},
"additionalProperties": false
},
"maxItems": 100
},
"payload": {
"description": "The PATCH body."
},
"callerSemantics": {
"type": "object",
"required": [
"omitted",
"null",
"emptyArray",
"emptyString"
],
"properties": {
"null": {
"enum": [
"clear",
"set-null",
"keep",
"invalid"
],
"type": "string"
},
"omitted": {
"enum": [
"keep",
"clear"
],
"type": "string"
},
"emptyArray": {
"enum": [
"clear",
"replace",
"keep"
],
"type": "string"
},
"emptyString": {
"enum": [
"clear",
"set",
"keep"
],
"type": "string"
}
},
"description": "Required when dialect is 'caller': what each payload form means in that API.",
"additionalProperties": false
}
},
"additionalProperties": false
}WARM verifiable agent memory — Persistent memory for AI agents as a pay-per-call API, no database to run. op=remember stores subject-predicate-object facts (or extracts them from free text; only facts whose subject and object appear verbatim are kept); a newer value for the same subject and predicate supersedes the old one, and the history stays queryable. op=recall searches by BM25 keyword ranking or exact triple pattern, now
| Argument | Type | Description |
|---|---|---|
| op* | string | |
| asOf | any | Epoch milliseconds or an ISO 8601 date/time (UTC when no offset). |
| said | string | |
| text | string | remember: free text; facts are extracted by a fast model and kept only if subject and object occur verbatim. |
| facts | array | |
| limit | integer | |
| query | string | |
| source | string | remember: provenance label for facts extracted from text. |
| history | string | recall: only facts current at asOf (default) or every status. |
Is this state transition allowed by the caller's workflow definition, and what is allowed instead? — Given a caller-supplied state machine (transitions with optional event names and required facts), the current state and a requested event or target state, says whether the transition is allowed, which required facts are false or unknown, and which transitions are available from the current state. For an agent about to move an order, ticket, deployment or approval to its next state. Terminal states
| Argument | Type | Description |
|---|---|---|
| facts | array | |
| current* | string | |
| request* | object | Give event, to, or both. |
| terminal | array | States with no outgoing transitions allowed even if listed. |
| transitions* | array |
{
"type": "object",
"required": [
"transitions",
"current",
"request"
],
"properties": {
"facts": {
"type": "array",
"items": {
"type": "object",
"required": [
"name",
"value"
],
"properties": {
"name": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"value": {
"type": "boolean"
}
},
"additionalProperties": false
},
"maxItems": 200
},
"current": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"request": {
"type": "object",
"properties": {
"to": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"event": {
"type": "string",
"maxLength": 200,
"minLength": 1
}
},
"description": "Give event, to, or both.",
"additionalProperties": false
},
"terminal": {
"type": "array",
"items": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"maxItems": 100,
"description": "States with no outgoing transitions allowed even if listed."
},
"transitions": {
"type": "array",
"items": {
"type": "object",
"required": [
"from",
"to"
],
"properties": {
"to": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"from": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"event": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"requires": {
"type": "array",
"items": {
"type": "string",
"maxLength": 200,
"minLength": 1
},
"maxItems": 20,
"description": "Names of facts that must be true."
}
},
"additionalProperties": false
},
"maxItems": 300,
"minItems": 1
}
},
"additionalProperties": false
}We read every tool's name, description and inputs the way the model will, looking for instructions hidden from you. A clean result means no warning signs, not a guarantee. Scanned Nov 15, 2026.
No readOnlyHint / destructiveHint annotations, so clients can't tell a read from a write without asking.
Fix: Add annotations to each tool, e.g. { readOnlyHint: true } for tools that only read.
| boolean |
| Default true when either revision is given (a missing partner gives unknown): an approval for another revision does not cover this one. Send false to ignore the revisions. |
{
"type": "object",
"required": [
"approved",
"current"
],
"properties": {
"asOf": {
"type": "string",
"maxLength": 40,
"description": "RFC 3339 instant for the expiry check; no clock is read."
},
"policy": {
"type": "object",
"properties": {
"fields": {
"type": "array",
"items": {
"type": "object",
"required": [
"path",
"rule"
],
"properties": {
"abs": {
"type": "number",
"maximum": 1000000000000000,
"minimum": 0,
"description": "numeric-tolerance: allowed absolute difference."
},
"pct": {
"type": "number",
"maximum": 1000,
"minimum": 0,
"description": "numeric-tolerance: allowed difference as percent of the approved value. Either bound being met is enough."
},
"path": {
"type": "string",
"maxLength": 300,
"description": "JSON Pointer prefix; \"*\" matches one token."
},
"rule": {
"enum": [
"exact",
"ignore",
"numeric-tolerance",
"no-increase",
"no-decrease"
],
"type": "string"
}
},
"additionalProperties": false
},
"maxItems": 100
},
"default": {
"enum": [
"material",
"ignore"
],
"type": "string",
"description": "Rule for paths no field rule covers. Default material (any change invalidates)."
}
},
"additionalProperties": false
},
"current": {
"description": "The version about to be executed (JSON)."
},
"approved": {
"description": "The approved snapshot (JSON)."
},
"approvedAt": {
"type": "string",
"maxLength": 40,
"description": "RFC 3339 instant."
},
"currentRevision": {
"type": "integer",
"maximum": 1000000000,
"minimum": 0
},
"validForSeconds": {
"type": "integer",
"maximum": 315360000,
"minimum": 0
},
"approvedRevision": {
"type": "integer",
"maximum": 1000000000,
"minimum": 0
},
"requireSameRevision": {
"type": "boolean",
"description": "Default true when either revision is given (a missing partner gives unknown): an approval for another revision does not cover this one. Send false to ignore the revisions."
}
},
"additionalProperties": false
}{
"type": "object",
"required": [
"messages"
],
"properties": {
"model": {
"type": "string",
"maxLength": 200,
"description": "Accepted and ignored: the hub routes by tier (the resource you paid for). Echoed as requested_model."
},
"top_p": {
"type": "number",
"description": "Accepted and ignored."
},
"messages": {
"type": "array",
"items": {
"type": "object",
"required": [
"role",
"content"
],
"properties": {
"role": {
"enum": [
"system",
"user",
"assistant"
],
"type": "string"
},
"content": {
"type": "string",
"maxLength": 100000,
"minLength": 1
}
},
"additionalProperties": false
},
"maxItems": 64,
"minItems": 1,
"description": "Conversation, oldest first; the last message must have role user. At most 200000 characters in total. System messages are joined into the instructions."
},
"max_tokens": {
"type": "integer",
"minimum": 1,
"description": "Upper bound on the reply in tokens; defaults to 1024. A value above the tier cap is rejected with 400."
},
"temperature": {
"type": "number",
"description": "Accepted and ignored."
},
"response_format": {
"type": "object",
"required": [
"type"
],
"properties": {
"type": {
"enum": [
"text",
"json_schema"
],
"type": "string"
},
"json_schema": {
"type": "object",
"required": [
"name",
"schema"
],
"properties": {
"name": {
"type": "string",
"pattern": "^[A-Za-z0-9_-]{1,64}$"
},
"schema": {
"type": "object",
"description": "Strict JSON Schema for the reply."
},
"strict": {
"type": "boolean",
"description": "Accepted for OpenAI compatibility; strict mode is always on."
}
},
"additionalProperties": false
}
},
"description": "Either {\"type\":\"text\"} (default) or {\"type\":\"json_schema\",\"json_schema\":{name,schema}}. The schema is always enforced strictly: root object, every property required, additionalProperties false, keywords limited to type, description, properties, required, additionalProperties, items, enum.",
"additionalProperties": false
}
},
"additionalProperties": false
}{
"type": "object",
"required": [
"messages"
],
"properties": {
"model": {
"type": "string",
"maxLength": 200,
"description": "Accepted and ignored: the hub routes by tier (the resource you paid for). Echoed as requested_model."
},
"top_p": {
"type": "number",
"description": "Accepted and ignored."
},
"messages": {
"type": "array",
"items": {
"type": "object",
"required": [
"role",
"content"
],
"properties": {
"role": {
"enum": [
"system",
"user",
"assistant"
],
"type": "string"
},
"content": {
"type": "string",
"maxLength": 100000,
"minLength": 1
}
},
"additionalProperties": false
},
"maxItems": 64,
"minItems": 1,
"description": "Conversation, oldest first; the last message must have role user. At most 200000 characters in total. System messages are joined into the instructions."
},
"max_tokens": {
"type": "integer",
"minimum": 1,
"description": "Upper bound on the reply in tokens; defaults to 1024. A value above the tier cap is rejected with 400."
},
"temperature": {
"type": "number",
"description": "Accepted and ignored."
},
"response_format": {
"type": "object",
"required": [
"type"
],
"properties": {
"type": {
"enum": [
"text",
"json_schema"
],
"type": "string"
},
"json_schema": {
"type": "object",
"required": [
"name",
"schema"
],
"properties": {
"name": {
"type": "string",
"pattern": "^[A-Za-z0-9_-]{1,64}$"
},
"schema": {
"type": "object",
"description": "Strict JSON Schema for the reply."
},
"strict": {
"type": "boolean",
"description": "Accepted for OpenAI compatibility; strict mode is always on."
}
},
"additionalProperties": false
}
},
"description": "Either {\"type\":\"text\"} (default) or {\"type\":\"json_schema\",\"json_schema\":{name,schema}}. The schema is always enforced strictly: root object, every property required, additionalProperties false, keywords limited to type, description, properties, required, additionalProperties, items, enum.",
"additionalProperties": false
}
},
"additionalProperties": false
}{
"type": "object",
"required": [
"messages"
],
"properties": {
"model": {
"type": "string",
"maxLength": 200,
"description": "Accepted and ignored: the hub routes by tier (the resource you paid for). Echoed as requested_model."
},
"top_p": {
"type": "number",
"description": "Accepted and ignored."
},
"messages": {
"type": "array",
"items": {
"type": "object",
"required": [
"role",
"content"
],
"properties": {
"role": {
"enum": [
"system",
"user",
"assistant"
],
"type": "string"
},
"content": {
"type": "string",
"maxLength": 100000,
"minLength": 1
}
},
"additionalProperties": false
},
"maxItems": 64,
"minItems": 1,
"description": "Conversation, oldest first; the last message must have role user. At most 200000 characters in total. System messages are joined into the instructions."
},
"max_tokens": {
"type": "integer",
"minimum": 1,
"description": "Upper bound on the reply in tokens; defaults to 1024. A value above the tier cap is rejected with 400."
},
"temperature": {
"type": "number",
"description": "Accepted and ignored."
},
"response_format": {
"type": "object",
"required": [
"type"
],
"properties": {
"type": {
"enum": [
"text",
"json_schema"
],
"type": "string"
},
"json_schema": {
"type": "object",
"required": [
"name",
"schema"
],
"properties": {
"name": {
"type": "string",
"pattern": "^[A-Za-z0-9_-]{1,64}$"
},
"schema": {
"type": "object",
"description": "Strict JSON Schema for the reply."
},
"strict": {
"type": "boolean",
"description": "Accepted for OpenAI compatibility; strict mode is always on."
}
},
"additionalProperties": false
}
},
"description": "Either {\"type\":\"text\"} (default) or {\"type\":\"json_schema\",\"json_schema\":{name,schema}}. The schema is always enforced strictly: root object, every property required, additionalProperties false, keywords limited to type, description, properties, required, additionalProperties, items, enum.",
"additionalProperties": false
}
},
"additionalProperties": false
}| observations | array |
{
"type": "object",
"required": [
"op",
"namespace",
"subject"
],
"properties": {
"op": {
"enum": [
"record",
"query"
],
"type": "string"
},
"subject": {
"type": "string",
"pattern": "^[A-Za-z0-9_.:/@+-]{1,200}$",
"description": "What was observed, e.g. api.stripe.com:POST:/v1/refunds, +18005551234:billing, or an error fingerprint."
},
"tenantId": {
"type": "string",
"pattern": "^[A-Za-z0-9_.-]{1,64}$",
"description": "Required for API-key callers (namespaced as key:<tenantId>; keep it unguessable). Ignored when a wallet paid: the payer address is the tenant."
},
"namespace": {
"enum": [
"endpoint-health",
"rate-limit",
"ivr-path",
"submission-outcome",
"failure-fix",
"feed-staleness",
"page-recipe",
"merchant-workflow",
"document-reputation",
"custom"
],
"type": "string"
},
"requestId": {
"type": "string",
"pattern": "^[A-Za-z0-9_.:-]{1,128}$",
"description": "Caller-chosen id for this mutation. A retry with the same id and same input returns the stored response (24 h) instead of applying twice; the same id with different input is rejected. Send one on every mutation you may retry: without it a retry is applied again (fleet-memory record appends a duplicate; a repeated spend-ledger commit or release answers NO_HOLD because the first call already took effect)."
},
"sinceHours": {
"type": "integer",
"maximum": 720,
"minimum": 1,
"description": "query window; default 168 (7 days)."
},
"observations": {
"type": "array",
"items": {
"type": "object",
"required": [
"outcome",
"observedAt"
],
"properties": {
"by": {
"type": "string",
"maxLength": 64,
"description": "Recording worker id."
},
"unit": {
"type": "string",
"maxLength": 16
},
"value": {
"type": "number",
"description": "Optional measurement, e.g. latency ms or hold minutes."
},
"detail": {
"type": "string",
"maxLength": 500,
"description": "e.g. the menu path 1,3,2 or the fix applied. Do not store personal data."
},
"outcome": {
"type": "string",
"pattern": "^[A-Za-z0-9_.:-]{1,64}$",
"description": "e.g. ok, timeout, 429, accepted, rejected, path-worked."
},
"observedAt": {
"type": "string",
"maxLength": 40,
"description": "ISO 8601 with offset; within the last 30 days."
}
},
"additionalProperties": false
},
"maxItems": 50
}
},
"additionalProperties": false
}{
"type": "object",
"required": [
"op",
"sequence"
],
"properties": {
"op": {
"enum": [
"next",
"peek"
],
"type": "string"
},
"count": {
"type": "integer",
"maximum": 1000,
"minimum": 1,
"description": "Ids to reserve; default 1."
},
"start": {
"type": "integer",
"maximum": 9007199254740990,
"minimum": 0,
"description": "First id of a new sequence; ignored once it exists. Default 1."
},
"sequence": {
"type": "string",
"pattern": "^[A-Za-z0-9_.:/@+-]{1,200}$",
"description": "Sequence name, e.g. invoice:2026."
},
"tenantId": {
"type": "string",
"pattern": "^[A-Za-z0-9_.-]{1,64}$",
"description": "Required for API-key callers (namespaced as key:<tenantId>; keep it unguessable). Ignored when a wallet paid: the payer address is the tenant."
},
"requestId": {
"type": "string",
"pattern": "^[A-Za-z0-9_.:-]{1,128}$",
"description": "Caller-chosen id for this mutation. A retry with the same id and same input returns the stored response (24 h) instead of applying twice; the same id with different input is rejected. Send one on every mutation you may retry: without it a retry is applied again (fleet-memory record appends a duplicate; a repeated spend-ledger commit or release answers NO_HOLD because the first call already took effect)."
}
},
"additionalProperties": false
}| fingerprint | string | Hash of the operation's identity fields; a later begin with a different fingerprint is refused. |
| claimSeconds | integer | How long a begin claim lasts; default 300. |
| retentionHours | integer | How long a completed key is remembered; default 24. |
{
"type": "object",
"required": [
"op",
"key"
],
"properties": {
"op": {
"enum": [
"begin",
"complete",
"abandon",
"get"
],
"type": "string"
},
"key": {
"type": "string",
"pattern": "^[A-Za-z0-9_.:/@+-]{1,200}$",
"description": "Idempotency key, e.g. refund:ch_123:2026-11-04."
},
"owner": {
"type": "string",
"maxLength": 128,
"minLength": 1,
"description": "Worker id; required for begin, complete and abandon."
},
"result": {
"type": "object",
"properties": {
"digest": {
"type": "string",
"maxLength": 128
},
"pointer": {
"type": "string",
"maxLength": 500
},
"summary": {
"type": "string",
"maxLength": 500
}
},
"description": "complete: where the outcome lives (do not store payloads here).",
"additionalProperties": false
},
"tenantId": {
"type": "string",
"pattern": "^[A-Za-z0-9_.-]{1,64}$",
"description": "Required for API-key callers (namespaced as key:<tenantId>; keep it unguessable). Ignored when a wallet paid: the payer address is the tenant."
},
"requestId": {
"type": "string",
"pattern": "^[A-Za-z0-9_.:-]{1,128}$",
"description": "Caller-chosen id for this mutation. A retry with the same id and same input returns the stored response (24 h) instead of applying twice; the same id with different input is rejected. Send one on every mutation you may retry: without it a retry is applied again (fleet-memory record appends a duplicate; a repeated spend-ledger commit or release answers NO_HOLD because the first call already took effect)."
},
"fingerprint": {
"type": "string",
"maxLength": 128,
"minLength": 1,
"description": "Hash of the operation's identity fields; a later begin with a different fingerprint is refused."
},
"claimSeconds": {
"type": "integer",
"maximum": 3600,
"minimum": 1,
"description": "How long a begin claim lasts; default 300."
},
"retentionHours": {
"type": "integer",
"maximum": 168,
"minimum": 1,
"description": "How long a completed key is remembered; default 24."
}
},
"additionalProperties": false
}| ttlSeconds |
| integer |
| Lease length; default 30. |
{
"type": "object",
"required": [
"op",
"resource"
],
"properties": {
"op": {
"enum": [
"acquire",
"renew",
"release",
"get"
],
"type": "string"
},
"token": {
"type": "integer",
"minimum": 1,
"description": "Fencing token from acquire; required for renew and release."
},
"holder": {
"type": "string",
"maxLength": 128,
"minLength": 1,
"description": "Your worker id. Required for acquire, renew and release."
},
"resource": {
"type": "string",
"pattern": "^[A-Za-z0-9_.:/@+-]{1,200}$",
"description": "Task or resource name, e.g. invoice:INV-1009 or deploy:prod."
},
"tenantId": {
"type": "string",
"pattern": "^[A-Za-z0-9_.-]{1,64}$",
"description": "Required for API-key callers (namespaced as key:<tenantId>; keep it unguessable). Ignored when a wallet paid: the payer address is the tenant."
},
"requestId": {
"type": "string",
"pattern": "^[A-Za-z0-9_.:-]{1,128}$",
"description": "Caller-chosen id for this mutation. A retry with the same id and same input returns the stored response (24 h) instead of applying twice; the same id with different input is rejected. Send one on every mutation you may retry: without it a retry is applied again (fleet-memory record appends a duplicate; a repeated spend-ledger commit or release answers NO_HOLD because the first call already took effect)."
},
"ttlSeconds": {
"type": "integer",
"maximum": 3600,
"minimum": 1,
"description": "Lease length; default 30."
}
},
"additionalProperties": false
}| zThreshold | number | z at or above which the result is fail. Default 4 (Kirchenbauer et al.). |
{
"type": "object",
"required": [],
"properties": {
"key": {
"type": "string",
"maxLength": 256,
"minLength": 1,
"description": "Secret key for tokenIds. Used for this call only and never stored or echoed."
},
"text": {
"type": "string",
"maxLength": 100000,
"minLength": 1,
"description": "Text to scan for invisible markers."
},
"gamma": {
"type": "number",
"maximum": 0.99,
"minimum": 0.01,
"description": "Expected green fraction under no watermark. Default 0.25."
},
"scheme": {
"enum": [
"hmac-sha256-green-1"
],
"type": "string",
"description": "Scheme for tokenIds; default and only value."
},
"tokenIds": {
"type": "array",
"items": {
"type": "integer",
"maximum": 2147483647,
"minimum": 0
},
"maxItems": 5000,
"description": "Token ids in order (at most 5000). Green membership is computed from the key with the hmac-sha256-green-1 scheme; each distinct consecutive pair is scored once."
},
"minTokens": {
"type": "integer",
"maximum": 1000,
"minimum": 5,
"description": "Fewer scored tokens than this is unknown. Default 25."
},
"greenFlags": {
"type": "array",
"items": {
"type": "integer",
"maximum": 1,
"minimum": 0
},
"maxItems": 100000,
"description": "One 0/1 per scored token: 1 when your own detector's green list contains the token. Deduplicate repeated n-grams yourself if your scheme requires it."
},
"zThreshold": {
"type": "number",
"maximum": 10,
"minimum": 1,
"description": "z at or above which the result is fail. Default 4 (Kirchenbauer et al.)."
}
},
"additionalProperties": false
}| stripTrailingWhitespace | boolean | Default true; a two-space hard break before more paragraph text is kept. |
{
"type": "object",
"required": [
"markdown"
],
"properties": {
"bullet": {
"enum": [
"-",
"*",
"+"
],
"type": "string",
"description": "Marker for unordered lists. Default '-'."
},
"markdown": {
"type": "string",
"maxLength": 100000,
"minLength": 1,
"description": "Markdown to normalize."
},
"finalNewline": {
"type": "boolean",
"description": "End with exactly one newline. Default true."
},
"fixHeadingSpace": {
"type": "boolean",
"description": "Restore the space in '##Title'. A lowercase '#tag' at level 1 is treated as a hashtag and left alone. Default true."
},
"closeUnclosedFence": {
"type": "boolean",
"description": "Append the closing fence when the document ends inside one. Default true."
},
"collapseBlankLines": {
"type": "boolean",
"description": "Collapse runs of blank lines and drop leading and trailing blanks. Default true."
},
"blankLinesAroundBlocks": {
"type": "boolean",
"description": "Insert a blank line around headings and top-level fenced blocks. Default true."
},
"stripTrailingWhitespace": {
"type": "boolean",
"description": "Default true; a two-space hard break before more paragraph text is kept."
}
},
"additionalProperties": false
}{
"type": "object",
"required": [
"text"
],
"properties": {
"text": {
"type": "string",
"maxLength": 100000,
"minLength": 1,
"description": "Prose to score."
},
"expect": {
"enum": [
"any",
"tense"
],
"type": "string",
"description": "tense: fail if the curve never reaches peakThreshold. any (default): only stalls after a peak can fail."
},
"window": {
"type": "integer",
"maximum": 20,
"minimum": 1,
"description": "Sentences in the trailing moving average. Default 3."
},
"stallDrop": {
"type": "number",
"maximum": 0.9,
"minimum": 0.05,
"description": "Fall below the running peak that counts as a stall. Default 0.25 on the 0-1 intensity scale."
},
"actionWords": {
"type": "array",
"items": {
"type": "string",
"maxLength": 40,
"minLength": 1,
"description": "Exact word, matched case-insensitively."
},
"maxItems": 500,
"description": "Your own action-word list. Without it the action component is left out and the other weights are renormalized."
},
"minSentences": {
"type": "integer",
"maximum": 100,
"minimum": 2,
"description": "Fewer scored sentences is unknown. Default 8."
},
"peakThreshold": {
"type": "number",
"maximum": 0.95,
"minimum": 0.1,
"description": "Smoothed intensity a passage must reach before a later fall can be a stall. Default 0.55."
}
},
"additionalProperties": false
}| retryAfter | string | Retry-After header value. |
| requestSent | string | Whether request bytes reached the network. connection-refused and dns-failure imply not-sent. |
| idempotencyKey | object | Caller-asserted evidence: the engine knows no vendor's key semantics. |
| previousAttemptWasAutomaticRetry | boolean |
{
"type": "object",
"required": [
"method",
"ended"
],
"properties": {
"asOf": {
"type": "string",
"maxLength": 40,
"description": "RFC 3339 instant; needed only to turn a Retry-After HTTP-date into seconds."
},
"actor": {
"enum": [
"client",
"proxy"
],
"type": "string"
},
"ended": {
"enum": [
"response",
"timeout",
"connection-reset",
"connection-refused",
"dns-failure",
"tls-failure",
"aborted-by-client"
],
"type": "string",
"description": "How the attempt ended."
},
"method": {
"type": "string",
"maxLength": 32,
"minLength": 1,
"description": "HTTP method, case-sensitive (GET, POST, ...)."
},
"policy": {
"type": "object",
"properties": {
"maxAttempts": {
"type": "integer",
"maximum": 1000,
"minimum": 1
},
"retryStatuses": {
"type": "array",
"items": {
"type": "integer",
"maximum": 599,
"minimum": 100
},
"maxItems": 50,
"description": "If given, only these statuses may be retried."
},
"maxWaitSeconds": {
"type": "integer",
"maximum": 31536000,
"minimum": 0
},
"notProcessedStatuses": {
"type": "array",
"items": {
"type": "integer",
"maximum": 599,
"minimum": 100
},
"maxItems": 50,
"description": "Statuses the vendor documents as 'rejected before processing'."
}
},
"additionalProperties": false
},
"status": {
"type": "integer",
"maximum": 599,
"minimum": 100,
"description": "Required when ended is 'response'."
},
"attempt": {
"type": "integer",
"maximum": 1000,
"minimum": 1,
"description": "1-based number of the attempt that just ended. Default 1."
},
"automatic": {
"type": "boolean",
"description": "True when the retry would be issued automatically (library or proxy) rather than by a deliberate decision."
},
"retryAfter": {
"type": "string",
"maxLength": 100,
"description": "Retry-After header value."
},
"requestSent": {
"enum": [
"unknown",
"not-sent",
"sent"
],
"type": "string",
"description": "Whether request bytes reached the network. connection-refused and dns-failure imply not-sent."
},
"idempotencyKey": {
"type": "object",
"required": [
"present"
],
"properties": {
"present": {
"type": "boolean"
},
"serverHonors": {
"enum": [
"yes",
"no",
"unknown"
],
"type": "string",
"description": "Whether the provider documents that it deduplicates on this key for this operation."
}
},
"description": "Caller-asserted evidence: the engine knows no vendor's key semantics.",
"additionalProperties": false
},
"previousAttemptWasAutomaticRetry": {
"type": "boolean"
}
},
"additionalProperties": false
}| integer |
| reserve: amount to hold. commit: amount actually spent (at most the hold). |
| budgetMinor | integer | open: total budget in minor units. |
| reservationId | string |
{
"type": "object",
"required": [
"op",
"ledger"
],
"properties": {
"op": {
"enum": [
"open",
"reserve",
"commit",
"release",
"status"
],
"type": "string"
},
"ledger": {
"type": "string",
"pattern": "^[A-Za-z0-9_.:/@+-]{1,200}$",
"description": "Ledger name, e.g. task:research-42."
},
"currency": {
"type": "string",
"pattern": "^[A-Z0-9]{2,12}$",
"description": "open: currency or token code, e.g. USD or USDC."
},
"tenantId": {
"type": "string",
"pattern": "^[A-Za-z0-9_.-]{1,64}$",
"description": "Required for API-key callers (namespaced as key:<tenantId>; keep it unguessable). Ignored when a wallet paid: the payer address is the tenant."
},
"requestId": {
"type": "string",
"pattern": "^[A-Za-z0-9_.:-]{1,128}$",
"description": "Caller-chosen id for this mutation. A retry with the same id and same input returns the stored response (24 h) instead of applying twice; the same id with different input is rejected. Send one on every mutation you may retry: without it a retry is applied again (fleet-memory record appends a duplicate; a repeated spend-ledger commit or release answers NO_HOLD because the first call already took effect)."
},
"ttlSeconds": {
"type": "integer",
"maximum": 86400,
"minimum": 1,
"description": "reserve: hold lifetime; default 600."
},
"amountMinor": {
"type": "integer",
"maximum": 1000000000000000,
"minimum": 0,
"description": "reserve: amount to hold. commit: amount actually spent (at most the hold)."
},
"budgetMinor": {
"type": "integer",
"maximum": 1000000000000000,
"minimum": 0,
"description": "open: total budget in minor units."
},
"reservationId": {
"type": "string",
"pattern": "^[A-Za-z0-9_.:-]{1,128}$"
}
},
"additionalProperties": false
}| attemptExitCodes |
| array |
| Exit codes of repeated runs of the same tests, to detect flakiness. Interpreted with the same runner rules. |
{
"type": "object",
"required": [
"runner"
],
"properties": {
"flags": {
"type": "object",
"properties": {
"failZero": {
"type": "boolean"
},
"posixExitCodes": {
"type": "boolean"
},
"passWithNoTests": {
"type": "boolean"
}
},
"additionalProperties": false
},
"counts": {
"type": "object",
"properties": {
"todo": {
"type": "integer",
"maximum": 10000000,
"minimum": 0
},
"flaky": {
"type": "integer",
"maximum": 10000000,
"minimum": 0,
"description": "Tests that failed then passed on retry."
},
"total": {
"type": "integer",
"maximum": 10000000,
"minimum": 0
},
"failed": {
"type": "integer",
"maximum": 10000000,
"minimum": 0
},
"passed": {
"type": "integer",
"maximum": 10000000,
"minimum": 0
},
"skipped": {
"type": "integer",
"maximum": 10000000,
"minimum": 0
}
},
"description": "Counts parsed by the caller from the runner's own report.",
"additionalProperties": false
},
"output": {
"type": "string",
"maxLength": 50000,
"description": "go test output (only ok, FAIL, --- FAIL and panic: lines are read)."
},
"runner": {
"enum": [
"pytest",
"jest",
"vitest",
"node-test",
"go-test",
"cargo-test",
"mocha"
],
"type": "string"
},
"signal": {
"type": "string",
"maxLength": 20,
"description": "Terminating signal name, e.g. SIGKILL."
},
"version": {
"type": "string",
"pattern": "^[0-9]+(\\.[0-9]+){0,2}$",
"maxLength": 30,
"description": "Runner version, e.g. 10.4.0. Needed only for version-gated flags."
},
"exitCode": {
"type": "integer",
"maximum": 255,
"minimum": 0,
"description": "Process exit status. Omit when the process was killed by a signal or timed out."
},
"timedOut": {
"type": "boolean",
"description": "True when the harness gave up waiting."
},
"attemptExitCodes": {
"type": "array",
"items": {
"type": "integer",
"maximum": 255,
"minimum": 0
},
"maxItems": 20,
"minItems": 2,
"description": "Exit codes of repeated runs of the same tests, to detect flakiness. Interpreted with the same runner rules."
}
},
"additionalProperties": false
}| number |
{
"type": "object",
"required": [
"op",
"bucket",
"capacity",
"refillPerSecond"
],
"properties": {
"op": {
"enum": [
"take",
"peek"
],
"type": "string"
},
"cost": {
"type": "number",
"maximum": 1000000,
"minimum": 0.000001,
"description": "Tokens to spend; default 1."
},
"bucket": {
"type": "string",
"pattern": "^[A-Za-z0-9_.:/@+-]{1,200}$",
"description": "Bucket name, e.g. openai:org-123:rpm."
},
"capacity": {
"type": "number",
"maximum": 1000000,
"minimum": 1
},
"tenantId": {
"type": "string",
"pattern": "^[A-Za-z0-9_.-]{1,64}$",
"description": "Required for API-key callers (namespaced as key:<tenantId>; keep it unguessable). Ignored when a wallet paid: the payer address is the tenant."
},
"requestId": {
"type": "string",
"pattern": "^[A-Za-z0-9_.:-]{1,128}$",
"description": "Caller-chosen id for this mutation. A retry with the same id and same input returns the stored response (24 h) instead of applying twice; the same id with different input is rejected. Send one on every mutation you may retry: without it a retry is applied again (fleet-memory record appends a duplicate; a repeated spend-ledger commit or release answers NO_HOLD because the first call already took effect)."
},
"refillPerSecond": {
"type": "number",
"maximum": 1000000,
"minimum": 0.000001
}
},
"additionalProperties": false
}| pattern | object | Exact (case- and whitespace-insensitive) match on any of subject, predicate, object. |
| tenantId | string | Required for API-key callers (namespace as key:<tenantId>; keep it unguessable). Ignored when a wallet paid. |
{
"type": "object",
"required": [
"op"
],
"properties": {
"op": {
"enum": [
"remember",
"recall",
"forget",
"explain"
],
"type": "string"
},
"asOf": {
"anyOf": [
{
"type": "integer",
"maximum": 8640000000000000,
"minimum": 0
},
{
"type": "string",
"maxLength": 40
}
],
"description": "Epoch milliseconds or an ISO 8601 date/time (UTC when no offset)."
},
"said": {
"type": "string",
"pattern": "^E[A-Za-z0-9_-]{43}$"
},
"text": {
"type": "string",
"maxLength": 8000,
"description": "remember: free text; facts are extracted by a fast model and kept only if subject and object occur verbatim."
},
"facts": {
"type": "array",
"items": {
"type": "object",
"required": [
"subject",
"predicate",
"object"
],
"properties": {
"object": {
"type": "string",
"maxLength": 500,
"minLength": 1
},
"source": {
"type": "string",
"maxLength": 500
},
"subject": {
"type": "string",
"maxLength": 500,
"minLength": 1
},
"validTo": {
"anyOf": [
{
"type": "integer",
"maximum": 8640000000000000,
"minimum": 0
},
{
"type": "string",
"maxLength": 40
}
],
"description": "Epoch milliseconds or an ISO 8601 date/time (UTC when no offset)."
},
"predicate": {
"type": "string",
"maxLength": 500,
"minLength": 1,
"description": "Single-valued slot per subject, e.g. lives_in; a newer fact supersedes the older."
},
"validFrom": {
"anyOf": [
{
"type": "integer",
"maximum": 8640000000000000,
"minimum": 0
},
{
"type": "string",
"maxLength": 40
}
],
"description": "Epoch milliseconds or an ISO 8601 date/time (UTC when no offset)."
}
},
"additionalProperties": false
},
"maxItems": 50
},
"limit": {
"type": "integer",
"maximum": 50,
"minimum": 1
},
"query": {
"type": "string",
"maxLength": 500
},
"source": {
"type": "string",
"maxLength": 500,
"description": "remember: provenance label for facts extracted from text."
},
"history": {
"enum": [
"current",
"all"
],
"type": "string",
"description": "recall: only facts current at asOf (default) or every status."
},
"pattern": {
"type": "object",
"properties": {
"object": {
"type": "string",
"maxLength": 500,
"minLength": 1
},
"subject": {
"type": "string",
"maxLength": 500,
"minLength": 1
},
"predicate": {
"type": "string",
"maxLength": 500,
"minLength": 1
}
},
"description": "Exact (case- and whitespace-insensitive) match on any of subject, predicate, object.",
"additionalProperties": false
},
"tenantId": {
"type": "string",
"pattern": "^[A-Za-z0-9_.-]{1,64}$",
"description": "Required for API-key callers (namespace as key:<tenantId>; keep it unguessable). Ignored when a wallet paid."
}
},
"additionalProperties": false
}