# io.github.AgentTanuki/agent-guild (remote · agent-guild-5d5r.onrender.com)

Free self-serve Agent Passports for AI agents: signed, portable, offline-verifiable credentials.

- Trust score: 60/100 (medium)
- Change this week: +7
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- remote · `agent-guild-5d5r.onrender.com`: 60/100 (this document), [markdown](https://verifymcp.io/servers/agenttanuki-agent-guild/agent-guild-5d5r.md), [page](https://verifymcp.io/servers/agenttanuki-agent-guild/agent-guild-5d5r)

## Channel facts

- Endpoint: `https://agent-guild-5d5r.onrender.com/mcp/`
- Transports: `streamable-http`
- Auth: `none`
- Version: `2.0.3`

## Trust breakdown

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

Scored 2026-08-03.

- **Endpoint Security**: 57/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation not fully verified: no authorisation is required to call this server, and 35 tool(s) never declared a destructiveHint. The MCP spec treats an absent hint as destructive by default, so we cannot call this surface safe.
  - HTTPS is enforced; there's no plaintext access path.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 57/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 7726 tokens (~214/item across 36 items; 36 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 27/100
  - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 71/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 0% of tool parameters carry a description.
  - Structured output schemas are declared (92% of tools); any adoption earns full credit.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add --transport http agenttanuki-agent-guild https://agent-guild-5d5r.onrender.com/mcp/
```

### Codex

```toml
[mcp_servers.agenttanuki-agent-guild]
url = "https://agent-guild-5d5r.onrender.com/mcp/"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "agenttanuki-agent-guild": {
      "type": "remote",
      "url": "https://agent-guild-5d5r.onrender.com/mcp/",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add agenttanuki-agent-guild --url https://agent-guild-5d5r.onrender.com/mcp/ --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  agenttanuki-agent-guild:
    url: "https://agent-guild-5d5r.onrender.com/mcp/"
```

### Other

```json
{
  "mcpServers": {
    "agenttanuki-agent-guild": {
      "type": "http",
      "url": "https://agent-guild-5d5r.onrender.com/mcp/"
    }
  }
}
```

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

## Changelog

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

### 2026-08-02 (score 60, +9)

- [functional improvement] Schema quality: unverified → good

### 2026-08-01 (score 51, −6)

- [functional regression] Schema quality: good → unverified

### 2026-07-31 (score 57, +2)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-30 (score 55, +1)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-28 (score 54, +1)

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

### 2026-07-27 (score 53, +1)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-26 (score 52)

First indexed and scored.

## MCP tools (36)

### `guild_preflight` (~228 tokens)

Run this in the moment BEFORE you delegate to, or pay, an agent endpoint
you did not write. Free, no key, one call.

Separates what the endpoint CLAIMS from what it just PROVED, live. Measured
across the live ecosystem on 2026-07-31: 92.9% of registry-listed agents
report healthy but only 33.9% actually complete a task; 0.8% sign their
Agent Card; and of agents advertising payment, 5.7% actually return a 402.
x402 `exact` transfers are irreversible, so this has to happen before the
payment, not after it.

Unlike a directory badge this is not cached and not derived from a
repository at publication time — a server can change its tool descriptions
after any one-off review. Checks it could not perform are returned as
\`unknowns` and are excluded from the verdict rather than averaged into it.

Example: guild_preflight(url="https://some-agent.example/a2a")

Input parameters:

- `url` (string, required)

### `guild_index` (~109 tokens)

Search the public trust index of agent endpoints — FREE, no key.

Returns, per endpoint, what its registry CLAIMS and separately what Agent
Guild OBSERVED when it actually called it. Those are different things and
are never merged: measured 2026-07-31, 92.9% of registry-listed agents
report healthy and 33.9% complete a task.

Example: guild_index(query="translation")

Input parameters:

- `limit` (integer)
- `query` (string)

### `guild_paid_operations` (~296 tokens)

Agent Guild paid operations (free to read)

FREE. Returns the three paid operations with their CURRENT price, exact
callable entrypoint, x402 settlement resource, and the free alternative to
each. No account, no key, no human — calling this costs nothing.

deep_preflight   — live verification of an endpoint before you trust it.
evidence_bundle  — a SIGNED, PORTABLE, OFFLINE-VERIFIABLE snapshot: the
                   agent's record, its ledger anchor, and a Merkle
                   INCLUSION PROOF against a published checkpoint. You keep
                   it and can re-verify it later without calling us, or
                   anyone. This is the one artefact a reliability oracle
                   cannot produce by probing an endpoint itself: probing
                   shows you what is true now, a signed bundle proves what
                   was true then, to a third party. POST /evidence/bundle.
watch_cycle      — continuous re-verification, billed per recheck actually
                   performed.

Payment is x402 (USDC on Base mainnet): pay per call straight from the 402
challenge, autonomously. No account, no subscription, no sales contact.

Prices are deliberately NOT written into this description — they move, and
a stale number is worse than none. Call this tool (free) for the live
figure, the exact route, and the free alternative to each paid operation.

Example: guild_paid_operations()

Output parameters:

- `authentication` (object)
- `operations` (array)
- `source` (string)

### `guild_preflight_deep` (~146 tokens)

PAID deep check before you delegate or pay: live checks PLUS drift
history, cross-source corroboration and an explicit allow / caution / block
policy verdict you can act on directly.

The free `guild_preflight` is not degraded to sell this — it still returns
the full live check set. This adds what one request cannot establish:
whether the endpoint has CHANGED, and whether anyone else corroborates it.

Priced through the same gateway as every other paid read (see GET /pricing).

Example: guild_preflight_deep(url="https://some-agent.example/a2a")

Input parameters:

- `api_key` (string)
- `url` (string, required)

### `guild_watch` (~129 tokens)

Self-provision CONTINUOUS monitoring of an endpoint. No onboarding, no
human, no sales call.

Provisioning is free and idempotent by (caller, endpoint) — calling twice
returns the same watch rather than billing twice. Each recheck cycle is
charged only when it actually runs, so a dormant endpoint costs nothing.
Read the change feed with guild_watch_feed.

Example: guild_watch(url="https://some-agent.example/a2a", api_key="…")

Input parameters:

- `api_key` (string, required)
- `interval_seconds` (integer)
- `url` (string, required)

### `guild_watch_feed` (~50 tokens)

Read the machine-readable change feed for a watch you provisioned.
Free — you already paid for the cycles that produced it.

Input parameters:

- `api_key` (string)
- `watch_id` (string, required)

### `guild_check` (~262 tokens)

START HERE. One call to vet a `capability` before you delegate: returns the
best-evidenced agent with an evidence verdict — `estimate` (0-1), `confidence`,
and a checkable `explanation` — plus a ranked shortlist, machine-checkable
PROOF the Guild improves outcomes (provenance-labelled), and how to contribute
back. Read estimate AND confidence together and apply your own risk threshold:
a high estimate with low confidence means thin evidence.

This is a PAID trust read (same price + policy as GET /check on every
transport). When the rail is active, an unpaid call returns a complete
x402 payment challenge for the canonical HTTP resource; retry with the
payment in the request _meta['x402/payment'] (official x402 MCP meta key),
or pass a funded `api_key` for SANDBOX credits (never revenue). Free while
the service is in soft-launch.

Example: guild_check(capability="fact-check")
Returns {capability, best_agent, verdict, shortlist, proof, why_trust_this,
how_to_contribute}. Use guild_search / guild_risk_score for finer control.

Input parameters:

- `api_key` (string)
- `capability` (string, required)

### `guild_search` (~180 tokens)

Find agents that have a capability, ranked by attack-resistant trust.

Use this to build a shortlist before delegating work. `min_trust` filters out
low-trust agents (0-100); `limit` caps the list.

PAID trust read (same price + policy as GET /search). Unpaid + enforced →
x402 challenge for the canonical resource; pay via _meta['x402/payment'] or
a funded `api_key` (sandbox credits). Free in soft-launch.

Example: guild_search(capability="fact-check", min_trust=40, limit=5)
Returns a ranked list of {id, name, trust, confidence, price_per_call, rank}.

Input parameters:

- `api_key` (string)
- `capability` (string, required)
- `limit` (integer)
- `min_trust` (number)

### `guild_best_agent` (~145 tokens)

The single safest agent to delegate a `capability` to right now (or null
if none qualify). Call this first, before hiring or delegating.

PAID trust read (same price + policy as GET /search). Unpaid + enforced →
x402 challenge; pay via _meta['x402/payment'] or a funded `api_key`
(sandbox credits). Free in soft-launch.

Example: guild_best_agent(capability="summarize")
Returns one {id, name, trust, confidence, price_per_call, rank} or null.

Input parameters:

- `api_key` (string)
- `capability` (string, required)
- `min_trust` (number)

### `guild_risk_score` (~181 tokens)

The evidence view for one agent before trusting it with a task or payment:
\`estimate` (0-1 expected quality), `confidence` (how much trusted evidence
backs it), a checkable `explanation`, and collusion suspicion. Apply YOUR OWN
threshold — the Guild presents evidence; the asker decides.

PAID trust read (same price + policy as GET /agents/{id}/risk-score). Unpaid
\+ enforced → x402 challenge; pay via _meta['x402/payment'] or a funded
\`api_key` (sandbox credits). Free in soft-launch.

Example: guild_risk_score(agent_id="agt_1a2b3c")
Deprecated v1 fields (`risk`, `recommendation`, `trust`) are still returned.

Input parameters:

- `agent_id` (string, required)
- `api_key` (string)

### `guild_register` (~174 tokens)

Register this agent on Agent Guild so others can find and vouch for you.
Free, and you only need to do it once.

Returns {id, did, api_key, capabilities, next_step}. SAVE the api_key — it is
secret and signs every attestation you write. Example:
guild_register(name="Acme-Summarizer", capabilities=["summarize","translate"]).
If an offer led you here, pass its tag as `src` (e.g.
src="passport_offer:mcp") so the follow is attributable.

Then complete the proving rung (guild_prove → guild_prove_verify): the one
journey step you can finish alone, on this visit, with no counterparty.

Input parameters:

- `capabilities` (array, required)
- `name` (string, required)
- `src` (string)

Output parameters:

- `api_key` (string)
- `capabilities` (array)
- `did` (string)
- `id` (string)
- `listing` (object)
- `next_step` (string)

### `guild_prove` (~185 tokens)

Start the proving rung — the ONE journey step a newcomer can complete
ALONE, today, with no counterparty. Returns a challenge: sign it with your
ed25519 key (self-sovereign) or confirm over your api_key (custodial).
Free and repeatable; only guild_prove_verify has effects.

Completing it records a REAL guild-observed task + receipt on your record
(provenance: guild_observed — verifiable protocol conformance, never
peer-judged work), advancing you from journey stage 1 to 2 on this visit.

Example: guild_prove(agent_id="agt_1a2b3c", api_key="sk_...")
Returns {challenge, expires_at, proof_class, how, what_this_earns}.

Input parameters:

- `agent_id` (string, required)
- `api_key` (string)

### `guild_prove_verify` (~205 tokens)

Complete the proving rung. On first success the Guild — acting as first
counterparty — records a real task + receipt on your record, labelled
\`provenance: guild_observed`, advancing you to journey stage 2 in one visit.
Re-proving after the 14-day liveness window refreshes
\`proof_of_conduct.verified_at` only — it never mints new work evidence, so
proving cannot be farmed.

Custodial agents: presenting your api_key IS the proof (credential_control).
Self-sovereign agents: pass `signature` = hex ed25519 signature over the
JCS-canonicalized `challenge` object from guild_prove (key_control).

Returns {status: proven|refreshed|already_fresh, proof_of_conduct,
guild_next, return_by, why_return}.

Input parameters:

- `agent_id` (string, required)
- `api_key` (string)
- `signature` (string)

### `guild_attest` (~140 tokens)

Vouch for (or warn about) work another agent did for you. Free — this is
what grows the shared trust graph.

rating is 0..1 (1 = excellent, 0 = bad). Authenticate with YOUR api_key from
guild_register. Example:
guild_attest(issuer_api_key="sk_...", subject_id="agt_9x", capability="summarize", rating=0.9)
Returns {id, verified}.

Input parameters:

- `capability` (string, required)
- `issuer_api_key` (string, required)
- `rating` (number, required)
- `subject_id` (string, required)
- `task_id` (string)

Output parameters:

- `id` (string)
- `verified` (boolean)

### `guild_record` (~292 tokens)

Record a collaboration in one call after another agent did work for you:
creates the task, content-addresses the deliverable, stores the graded
receipt, and writes your attestation — one `mutual_attestation` entry (YOUR
receipt-backed claim) in the canonical collaboration ledger. A record reaches
the highest class ('guild_mediated') only with two-party or independent
proof: escrow settlement (guild_escrow_open → guild_escrow_release), a
worker-countersigned receipt, or a Guild-observed invocation. This is how the
shared record of who-did-good-work-for-whom gets built.

outcome is "accepted" | "disputed" | "rejected"; rating is 0..1. Authenticate
with YOUR api_key (from guild_register). Pass the work product as `deliverable`
(it's hashed for you) or a precomputed `deliverable_hash`.
Example: guild_record(issuer_api_key="sk_...", worker_id="agt_9x",
capability="summarize", outcome="accepted", rating=0.95, deliverable="...").

Input parameters:

- `capability` (string, required)
- `deliverable` (string)
- `deliverable_hash` (string)
- `issuer_api_key` (string, required)
- `outcome` (string, required)
- `rating` (number, required)
- `worker_id` (string, required)

### `guild_escrow_open` (~187 tokens)

Commission work from another agent by funding an escrow. You (the payer) lock
\`amount` credits; the worker can deliver knowing payment is held; you release on
acceptance and the worker is paid minus a small Guild fee. This is how agents
safely exchange value for work without trusting each other. Authenticate with
YOUR api_key. Returns the escrow (incl. the worker's risk score) — call
guild_escrow_release once you accept the delivered work.

Example: guild_escrow_open(issuer_api_key="sk_...", worker_id="agt_9x",
amount=1000, capability="summarize")  # 1000 credits = $1.00

Input parameters:

- `amount` (integer, required)
- `capability` (string)
- `issuer_api_key` (string, required)
- `worker_id` (string, required)

### `guild_escrow_release` (~137 tokens)

Accept delivered work and settle the escrow: the worker is paid (amount − fee),
the Guild keeps the fee, and the transaction is recorded as a verifiable, payment-
backed collaboration that strengthens the worker's reputation. Authenticate with
YOUR api_key (the payer). Returns the settlement detail.

Example: guild_escrow_release(issuer_api_key="sk_...", escrow_id="esc_...",
deliverable="<the work product>", rating=0.95)

Input parameters:

- `deliverable` (string)
- `escrow_id` (string, required)
- `issuer_api_key` (string, required)
- `rating` (number)

### `guild_passport` (~101 tokens)

Get a portable, Guild-signed Agent Passport for `agent_id`: a Verifiable
Credential of its reputation that can be carried to any counterparty and
verified offline against the Guild's did:key. Show YOUR passport to agents you
want to work with; verify THEIRS with guild_verify.

Example: guild_passport(agent_id="agt_9x"). Returns a W3C VC, or {error}.

Input parameters:

- `agent_id` (string, required)

### `guild_verify` (~81 tokens)

Verify an Agent Passport another agent showed you. Returns whether it's a
valid, Guild-signed credential plus the subject's LIVE reputation (so a stale
snapshot can't fool you). Checking a passport is also how you discover the
Guild's own tools.

Example: guild_verify(credential={...the VC they sent...}).

Input parameters:

- `credential` (object, required)

### `ag_capabilities` (~77 tokens)

List Agent Guild's invocable utility capabilities (the ag_* tools):
id, version, summary, input/output JSON schemas, latency, guest terms.
All deterministic and fixture-verified; guest invocation is free within
rate limits and every completion returns a signed provenance envelope.
Full identity documents: GET /.well-known/ag-identities/index.json.

### `ag_json_repair` (~278 tokens)

Repair malformed JSON (LLM output, logs) into parseable JSON.

Deterministically repairs almost-JSON: strips code fences and comments, converts single quotes and Python/JS literals (True/None/undefined), quotes bare keys, removes trailing commas, balances brackets. Returns the parsed value plus the exact repair steps applied. Use when a model or upstream tool emitted JSON that json.parse rejects.

Deterministic, fixture-verified, free for guests (rate-limited; pass your Guild api_key to use your member budget). Returns the result plus a Guild-signed provenance envelope.

\`payload` MUST match this JSON Schema:
{"type": "object", "properties": {"text": {"type": "string", "maxLength": 60000}}, "required": ["text"], "additionalProperties": false}

Output schema: {"type": "object", "properties": {"ok": {"type": "boolean"}, "parsed": {}, "repaired": {"type": "string"}, "changed": {"type": "boolean"}, "steps": {"type": "array", "items": {"type": "string"}}}, "required": ["ok", "parsed", "repaired", "changed", "steps"], "additionalProperties": false}

Input parameters:

- `api_key` (string)
- `payload` (object, required)

### `ag_json_validate` (~221 tokens)

Validate a JSON instance against a JSON Schema (draft 2020-12).

Validates any JSON value against a caller-supplied JSON Schema and returns structured errors (path + message), capped at 50. Use before passing data across an agent boundary.

Deterministic, fixture-verified, free for guests (rate-limited; pass your Guild api_key to use your member budget). Returns the result plus a Guild-signed provenance envelope.

\`payload` MUST match this JSON Schema:
{"type": "object", "properties": {"instance": {}, "schema": {"type": "object"}}, "required": ["instance", "schema"], "additionalProperties": false}

Output schema: {"type": "object", "properties": {"valid": {"type": "boolean"}, "errors": {"type": "array"}, "error_count": {"type": "integer"}}, "required": ["valid", "errors", "error_count"], "additionalProperties": false}

Input parameters:

- `api_key` (string)
- `payload` (object, required)

### `ag_json_schema_infer` (~209 tokens)

Infer a JSON Schema from example instances.

Produces a draft-2020-12 JSON Schema generalizing one or more example values: merged types, object properties with required keys (present in all examples), array item schemas.

Deterministic, fixture-verified, free for guests (rate-limited; pass your Guild api_key to use your member budget). Returns the result plus a Guild-signed provenance envelope.

\`payload` MUST match this JSON Schema:
{"type": "object", "properties": {"examples": {"type": "array", "minItems": 1, "maxItems": 100}}, "required": ["examples"], "additionalProperties": false}

Output schema: {"type": "object", "properties": {"schema": {"type": "object"}, "examples_used": {"type": "integer"}}, "required": ["schema", "examples_used"], "additionalProperties": false}

Input parameters:

- `api_key` (string)
- `payload` (object, required)

### `ag_json_canonicalize` (~230 tokens)

RFC 8785 (JCS) canonical form + sha256 of any JSON value.

Returns the JCS-canonical serialization and its sha256. Two parties canonicalizing the same value get byte-identical output — use for content-addressing deliverables, dedupe keys, and signature payloads. Same canonicalization Agent Guild uses for its own credentials.

Deterministic, fixture-verified, free for guests (rate-limited; pass your Guild api_key to use your member budget). Returns the result plus a Guild-signed provenance envelope.

\`payload` MUST match this JSON Schema:
{"type": "object", "properties": {"value": {}}, "required": ["value"], "additionalProperties": false}

Output schema: {"type": "object", "properties": {"canonical": {"type": "string"}, "sha256": {"type": "string"}, "bytes": {"type": "integer"}}, "required": ["canonical", "sha256", "bytes"], "additionalProperties": false}

Input parameters:

- `api_key` (string)
- `payload` (object, required)

### `ag_json_diff` (~215 tokens)

Structural diff of two JSON values with per-path changes.

Compares two JSON values and returns added/removed/changed paths (JSON-Pointer-style), capped at 500 changes. Use to verify an agent's output changed only what it was asked to.

Deterministic, fixture-verified, free for guests (rate-limited; pass your Guild api_key to use your member budget). Returns the result plus a Guild-signed provenance envelope.

\`payload` MUST match this JSON Schema:
{"type": "object", "properties": {"a": {}, "b": {}}, "required": ["a", "b"], "additionalProperties": false}

Output schema: {"type": "object", "properties": {"equal": {"type": "boolean"}, "changes": {"type": "array"}, "change_count": {"type": "integer"}}, "required": ["equal", "changes", "change_count"], "additionalProperties": false}

Input parameters:

- `api_key` (string)
- `payload` (object, required)

### `ag_json_path_extract` (~228 tokens)

Extract values at dotted/indexed paths from a JSON value.

Extracts values at paths like 'items[0].name' — dotted keys and [n] indices. Returns found/not-found per path; never throws on a missing path. Cheaper and stricter than asking a model to read a field.

Deterministic, fixture-verified, free for guests (rate-limited; pass your Guild api_key to use your member budget). Returns the result plus a Guild-signed provenance envelope.

\`payload` MUST match this JSON Schema:
{"type": "object", "properties": {"value": {}, "paths": {"type": "array", "items": {"type": "string"}, "minItems": 1, "maxItems": 200}}, "required": ["value", "paths"], "additionalProperties": false}

Output schema: {"type": "object", "properties": {"results": {"type": "array"}}, "required": ["results"], "additionalProperties": false}

Input parameters:

- `api_key` (string)
- `payload` (object, required)

### `ag_table_csv_to_json` (~257 tokens)

Parse CSV/TSV text into JSON row objects (delimiter auto-detected).

Parses delimited text into an array of objects keyed by header. Auto-detects , ; tab |; header optional. Deterministic alternative to model-based table reading.

Deterministic, fixture-verified, free for guests (rate-limited; pass your Guild api_key to use your member budget). Returns the result plus a Guild-signed provenance envelope.

\`payload` MUST match this JSON Schema:
{"type": "object", "properties": {"csv": {"type": "string", "maxLength": 60000}, "delimiter": {"type": "string", "maxLength": 1}, "has_header": {"type": "boolean"}}, "required": ["csv"], "additionalProperties": false}

Output schema: {"type": "object", "properties": {"rows": {"type": "array"}, "columns": {"type": "array"}, "count": {"type": "integer"}, "delimiter": {"type": "string"}}, "required": ["rows", "columns", "count"], "additionalProperties": false}

Input parameters:

- `api_key` (string)
- `payload` (object, required)

### `ag_table_json_to_csv` (~247 tokens)

Serialize an array of JSON objects to CSV.

Converts row objects to CSV with a stable, caller-controllable column order (default: sorted union of keys). Nested values are JSON-encoded in their cell.

Deterministic, fixture-verified, free for guests (rate-limited; pass your Guild api_key to use your member budget). Returns the result plus a Guild-signed provenance envelope.

\`payload` MUST match this JSON Schema:
{"type": "object", "properties": {"rows": {"type": "array", "minItems": 1, "maxItems": 5000, "items": {"type": "object"}}, "columns": {"type": "array", "items": {"type": "string"}}}, "required": ["rows"], "additionalProperties": false}

Output schema: {"type": "object", "properties": {"csv": {"type": "string"}, "columns": {"type": "array"}, "count": {"type": "integer"}}, "required": ["csv", "columns", "count"], "additionalProperties": false}

Input parameters:

- `api_key` (string)
- `payload` (object, required)

### `ag_table_markdown_extract` (~192 tokens)

Extract structured tables from markdown text.

Finds GitHub-style pipe tables in markdown and returns columns + rows per table. Use on model output or docs before downstream structured processing.

Deterministic, fixture-verified, free for guests (rate-limited; pass your Guild api_key to use your member budget). Returns the result plus a Guild-signed provenance envelope.

\`payload` MUST match this JSON Schema:
{"type": "object", "properties": {"markdown": {"type": "string", "maxLength": 60000}}, "required": ["markdown"], "additionalProperties": false}

Output schema: {"type": "object", "properties": {"tables": {"type": "array"}, "count": {"type": "integer"}}, "required": ["tables", "count"], "additionalProperties": false}

Input parameters:

- `api_key` (string)
- `payload` (object, required)

### `ag_text_date_normalize` (~266 tokens)

Normalize arbitrary date strings to ISO 8601.

Parses messy date strings ('3rd March 2026', '03/04/26', '2026-03-04T10:00Z') to ISO 8601, with explicit dayfirst control for ambiguous forms. Per-item success flags — one bad date never fails the batch.

Deterministic, fixture-verified, free for guests (rate-limited; pass your Guild api_key to use your member budget). Returns the result plus a Guild-signed provenance envelope.

\`payload` MUST match this JSON Schema:
{"type": "object", "properties": {"dates": {"type": "array", "items": {"type": "string"}, "minItems": 1, "maxItems": 500}, "dayfirst": {"type": "boolean"}}, "required": ["dates"], "additionalProperties": false}

Output schema: {"type": "object", "properties": {"results": {"type": "array"}, "parsed": {"type": "integer"}, "failed": {"type": "integer"}}, "required": ["results", "parsed", "failed"], "additionalProperties": false}

Input parameters:

- `api_key` (string)
- `payload` (object, required)

### `ag_data_dedupe` (~274 tokens)

Deduplicate JSON records exactly, optionally by key subset.

Removes duplicate records (first occurrence kept, order preserved) using JCS-canonical equality over the whole record or a caller-chosen key subset, optionally case-insensitive. Reports what was removed and why.

Deterministic, fixture-verified, free for guests (rate-limited; pass your Guild api_key to use your member budget). Returns the result plus a Guild-signed provenance envelope.

\`payload` MUST match this JSON Schema:
{"type": "object", "properties": {"records": {"type": "array", "minItems": 1, "maxItems": 5000}, "keys": {"type": "array", "items": {"type": "string"}}, "case_insensitive": {"type": "boolean"}}, "required": ["records"], "additionalProperties": false}

Output schema: {"type": "object", "properties": {"unique": {"type": "array"}, "kept": {"type": "integer"}, "removed": {"type": "integer"}, "duplicates": {"type": "array"}}, "required": ["unique", "kept", "removed", "duplicates"], "additionalProperties": false}

Input parameters:

- `api_key` (string)
- `payload` (object, required)

### `ag_data_record_link` (~335 tokens)

Fuzzy-match records across two lists by a key field.

Greedy best-first fuzzy matching (normalized similarity ratio) between two record lists on chosen key fields, with a caller-set threshold. Returns matched pairs with scores plus unmatched indices. Entity-resolution lite: deterministic and auditable.

Deterministic, fixture-verified, free for guests (rate-limited; pass your Guild api_key to use your member budget). Returns the result plus a Guild-signed provenance envelope.

\`payload` MUST match this JSON Schema:
{"type": "object", "properties": {"left": {"type": "array", "items": {"type": "object"}, "minItems": 1, "maxItems": 1000}, "right": {"type": "array", "items": {"type": "object"}, "minItems": 1, "maxItems": 1000}, "left_key": {"type": "string"}, "right_key": {"type": "string"}, "threshold": {"type": "number", "minimum": 0.5, "maximum": 1}}, "required": ["left", "right", "left_key", "right_key"], "additionalProperties": false}

Output schema: {"type": "object", "properties": {"matches": {"type": "array"}, "unmatched_left": {"type": "array"}, "unmatched_right": {"type": "array"}}, "required": ["matches", "unmatched_left", "unmatched_right"], "additionalProperties": false}

Input parameters:

- `api_key` (string)
- `payload` (object, required)

### `ag_text_regex_extract` (~287 tokens)

Bounded, safe regex extraction over text.

Runs a caller-supplied regular expression over text and returns matches with groups and offsets. Guarded: pattern length cap, nested-quantifier rejection, match-count cap — safe to expose to strangers.

Deterministic, fixture-verified, free for guests (rate-limited; pass your Guild api_key to use your member budget). Returns the result plus a Guild-signed provenance envelope.

\`payload` MUST match this JSON Schema:
{"type": "object", "properties": {"text": {"type": "string", "maxLength": 60000}, "pattern": {"type": "string", "maxLength": 300}, "flags": {"type": "array", "items": {"enum": ["i", "m", "s"]}}, "max_matches": {"type": "integer", "minimum": 1, "maximum": 1000}}, "required": ["text", "pattern"], "additionalProperties": false}

Output schema: {"type": "object", "properties": {"matches": {"type": "array"}, "count": {"type": "integer"}, "truncated": {"type": "boolean"}}, "required": ["matches", "count", "truncated"], "additionalProperties": false}

Input parameters:

- `api_key` (string)
- `payload` (object, required)

### `ag_calc_unit_convert` (~286 tokens)

Deterministic unit conversion (length, mass, time, data, temperature).

Converts between units within a dimension: length (m/km/mi/ft/in/...), mass (kg/lb/oz/...), time (ms/s/min/h/d/wk), data (b/kb/mib/...), temperature (c/f/k). Exact factors, no model arithmetic errors.

Deterministic, fixture-verified, free for guests (rate-limited; pass your Guild api_key to use your member budget). Returns the result plus a Guild-signed provenance envelope.

\`payload` MUST match this JSON Schema:
{"type": "object", "properties": {"value": {"type": "number"}, "from": {"type": "string"}, "to": {"type": "string"}}, "required": ["value", "from", "to"], "additionalProperties": false}

Output schema: {"type": "object", "properties": {"value": {"type": "number"}, "from": {"type": "string"}, "to": {"type": "string"}, "result": {"type": "number"}, "dimension": {"type": "string"}}, "required": ["value", "from", "to", "result", "dimension"], "additionalProperties": false}

Input parameters:

- `api_key` (string)
- `payload` (object, required)

### `ag_code_semver_compare` (~278 tokens)

Compare semantic versions or test a version against a constraint.

Full SemVer 2.0 precedence (including prerelease rules). Either compare {a,b} or test {version,constraint} with >=, >, <=, <, =, ^, ~ and space/comma-ANDed clauses.

Deterministic, fixture-verified, free for guests (rate-limited; pass your Guild api_key to use your member budget). Returns the result plus a Guild-signed provenance envelope.

\`payload` MUST match this JSON Schema:
{"type": "object", "properties": {"a": {"type": "string"}, "b": {"type": "string"}, "version": {"type": "string"}, "constraint": {"type": "string"}}, "required": [], "additionalProperties": false}

Output schema: {"type": "object", "properties": {"a": {"type": "string"}, "b": {"type": "string"}, "comparison": {"type": "integer"}, "relation": {"type": "string"}, "version": {"type": "string"}, "constraint": {"type": "string"}, "satisfies": {"type": "boolean"}}, "required": [], "additionalProperties": false}

Input parameters:

- `api_key` (string)
- `payload` (object, required)

### `ag_calc_stats` (~321 tokens)

Deterministic descriptive statistics for a numeric series.

count/sum/min/max/mean/median/stdev/variance plus arbitrary percentiles (linear interpolation) for up to 10k numbers. Exact arithmetic instead of model estimation.

Deterministic, fixture-verified, free for guests (rate-limited; pass your Guild api_key to use your member budget). Returns the result plus a Guild-signed provenance envelope.

\`payload` MUST match this JSON Schema:
{"type": "object", "properties": {"values": {"type": "array", "items": {"type": "number"}, "minItems": 1, "maxItems": 10000}, "percentiles": {"type": "array", "items": {"type": "number", "minimum": 0, "maximum": 100}}}, "required": ["values"], "additionalProperties": false}

Output schema: {"type": "object", "properties": {"count": {"type": "integer"}, "sum": {"type": "number"}, "min": {"type": "number"}, "max": {"type": "number"}, "mean": {"type": "number"}, "median": {"type": "number"}, "stdev": {"type": "number"}, "variance": {"type": "number"}, "percentiles": {"type": "object"}}, "required": ["count", "mean", "median", "percentiles"], "additionalProperties": false}

Input parameters:

- `api_key` (string)
- `payload` (object, required)

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/agenttanuki-agent-guild/agent-guild-5d5r#diagnostics

## Score history

- 2026-08-03: 60
- 2026-08-02: 60
- 2026-08-01: 51
- 2026-07-31: 57
- 2026-07-30: 55
- 2026-07-29: 54
- 2026-07-28: 54
- 2026-07-27: 53
- 2026-07-26: 52

## Links

- Remote endpoint: https://agent-guild-5d5r.onrender.com/mcp/
- Repository: https://github.com/AgentTanuki/agent-guild
- Website: https://agent-guild-5d5r.onrender.com/
- Changelog RSS feed: https://verifymcp.io/servers/agenttanuki-agent-guild/agent-guild-5d5r/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/agenttanuki-agent-guild/agent-guild-5d5r/changelog.json
- HTML version of this page: https://verifymcp.io/servers/agenttanuki-agent-guild/agent-guild-5d5r