agent-guild

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It details determinism, exact arithmetic, rate-limiting, and a Guild-signed provenance envelope. This fully discloses behavioral traits.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured with a clear purpose statement, list of features, and a detailed payload schema. It is front-loaded and informative, though slightly lengthy due to the embedded JSON schema.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has a complex nested payload and an output schema, the description covers input constraints, behavior, and output structure thoroughly. The output schema is provided separately, completing the picture.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, but the description provides a comprehensive JSON schema for the payload parameter, including constraints on values and percentiles. It also mentions the api_key parameter's role. This adds significant meaning beyond the minimal input schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool computes deterministic descriptive statistics for a numeric series, listing specific metrics (count, sum, min, max, mean, median, stdev, variance, percentiles). It is distinct from siblings like ag_calc_unit_convert.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear context: deterministic, fixture-verified, free for guests with rate limits, and mentions using api_key for member budget. It specifies payload must match a given JSON schema and limits values to up to 10k numbers. However, it does not explicitly state when to use vs. alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, but description fully discloses: deterministic, exact factors, no arithmetic errors, fixture-verified, rate-limiting, provenance envelope. Contradictions: none.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Well-structured: purpose first, then details on determinism, pricing, and schema. Somewhat verbose but all sentences add value. Could be slightly tighter.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Covers input format, behavior, constraints, output schema, and authentication. No gaps given presence of output schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, but description adds full payload JSON Schema with required properties and output schema. Explains api_key is for member budget. Could elaborate more on unit notation but sufficient.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Description states 'Deterministic unit conversion (length, mass, time, data, temperature)' with specific verb and resource. Lists example units and dimensions, clearly distinguishing from siblings like ag_calc_stats or ag_capabilities.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides context: deterministic, free for guests, rate-limited, use api_key for member budget. Does not explicitly state when not to use or mention alternatives, but implied for unit conversion needs.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description fully discloses behavior: deterministic, fixture-verified, free within rate limits, and returns a signed provenance envelope. It also references identity documents location.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise with three sentences, no fluff, and essential information front-loaded. Each sentence adds value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given zero parameters and presence of output schema, the description is complete. It covers purpose, behavior, and additional references, leaving no gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

No parameters exist, so schema coverage is 100%, baseline 4. The description adds meaning about output content (id, version, summary, etc.), aligning with baseline.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool lists 'Agent Guild's invocable utility capabilities (the ag_* tools)' with specific metadata fields. It distinguishes from sibling tools by its listing function, not performing actions.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like individual ag_* tools. It does not mention when not to use it or direct users to other tools for specific tasks.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description fully carries the behavioral transparency burden. It discloses that the tool is deterministic, fixture-verified, free but rate-limited, and returns a provenance envelope. It also includes the exact input and output schemas.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured and front-loaded with a one-line summary. Every sentence adds value, covering SemVer rules, usage modes, behavioral details, and input/output schemas. No unnecessary repetition.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity and the presence of an output schema, the description provides all necessary information: input format, behavior, constraints, security (api_key), and return structure. It is complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Although the schema coverage is 0%, the description explicitly defines the payload JSON Schema, listing allowed properties (a, b, version, constraint) and how they are used. This adds significant meaning beyond the generic input schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it compares semantic versions or tests a version against a constraint, following SemVer 2.0 precedence. It uses specific verbs (compare, test) and identifies the resource (semantic versions). It distinguishes itself from sibling tools like ag_text_date_normalize.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explains when to use the tool (comparing two versions or testing against a constraint) and lists supported operators. It provides clear context but does not explicitly state when not to use it or name alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description fully discloses key behaviors: JCS-canonical equality, order preservation, case-insensitive option, deterministic, fixture-verified, rate limits, provenance envelope, and detailed removal reporting.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is front-loaded and each sentence adds value, though some procedural details could be slightly more concise without losing clarity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the output schema and complex nested payload, the description covers all necessary details: constraints (min/max records), logic, output fields, and provenance, making it complete for agent usage.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, but the description includes a full JSON Schema for the payload and explains each parameter (records, keys, case_insensitive) and the api_key optional parameter.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool deduplicates JSON records exactly, optionally by key subset, and distinguishes it from siblings like ag_json_diff or ag_json_canonicalize.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides clear context for usage (deterministic, rate-limited, free for guests) but does not explicitly state when not to use or explicitly name alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations exist, so description carries full burden. It discloses deterministic behavior, fixture verification, free usage with rate limits, and that it returns a provenance envelope. It clarifies that the payload must match a specific JSON schema, providing full schema. No contradictions.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured with a summary first, then algorithm details, behavioral notes, and payload schema. While the inline schema is verbose, it adds clarity for the agent. Every sentence adds value, though slightly longer than minimal.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (fuzzy matching on two lists with threshold, deterministic output, provenance), the description covers all aspects: algorithm, constraints, authentication (api_key), output schema, and behavioral guarantees. No gaps for an AI agent to select and invoke correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has only generic parameters (api_key, payload), but the description provides a detailed JSON schema for payload with explicit fields: left, right, left_key, right_key, threshold. It explains each field's role—lists, keys for matching, and similarity threshold.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool performs fuzzy matching of records across two lists by key fields. It specifies the algorithm (greedy best-first, normalized similarity ratio), threshold, and outputs (matched pairs, unmatched indices). It is distinct from sibling tools like ag_data_dedupe which deduplicates within a single list.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implicitly tells when to use (entity-resolution between two lists) but does not explicitly contrast with alternatives like ag_data_dedupe or other data tools. No guidance on when not to use or prerequisites beyond free/rate-limited usage.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided; description fully discloses determinism, fixture verification, rate limits, and the Guild-signed provenance envelope. Also specifies payload schema requirements and output structure.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Single paragraph, front-loaded with purpose, no redundant sentences. Every sentence adds value (behavior, use cases, constraints, output).

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Output schema provided, so return values are clear. Description covers payload constraints, api_key purpose, rate limits, and provenance. Complete for a utility tool of this complexity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, but description adds critical meaning: `payload` must match a given JSON Schema with required 'value', and `api_key` is explained as optional for member budget. Compensates fully for missing schema descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly states the tool produces RFC 8785 (JCS) canonical serialization and SHA-256 hash of any JSON value. Distinguishes from siblings like `ag_json_validate` or `ag_json_diff` by focusing on canonicalization and hashing.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides explicit use cases (content-addressing, dedupe keys, signature payloads) and conditions (free for guests, rate-limited, optional api_key). Does not explicitly tell when not to use, but context is clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It discloses deterministic behavior, fixture-verified, rate limits, and that it returns a provenance envelope. It does not cover error handling or large input behavior, but for a diff tool this is adequate context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two paragraphs, front-loaded with purpose, and every sentence adds value (purpose, use case, constraints, schema requirements). No unnecessary words or repetition.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the presence of an output schema, the description need not explain return values. It covers input constraints (payload schema, cap at 500 changes), behavioral traits (deterministic, rate-limited), and provenance. Missing error handling details, but otherwise complete for the tool's complexity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0% (no descriptions in input schema). The description compensates fully: it specifies that 'payload' must match a given JSON Schema with 'a' and 'b' properties, and mentions 'api_key' implicitly via rate limit context. This adds critical meaning beyond the raw schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'Structural diff of two JSON values with per-path changes', specifying the verb (diff), resource (JSON values), and scope. It distinguishes itself from sibling tools like ag_json_validate or ag_json_path_extract by focusing on comparing two values.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives explicit use case: 'Use to verify an agent's output changed only what it was asked to.' It also mentions constraints like rate limiting and the payload schema requirement. However, it does not explicitly contrast with alternatives or say when not to use it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description discloses key behaviors: never throws on missing path, deterministic, free for guests with rate limiting, and returns a provenance envelope. It covers performance and authentication needs adequately.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Description is moderately concise; each sentence adds relevant detail. Could be slightly streamlined but remains clear and informative without excessive length.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool complexity and no annotations, the description covers path syntax, error handling, performance, cost model, authentication, and payload schema. Output schema is provided, so return values are clear.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description adds significant value by explaining the payload structure (must have value and paths arrays) and the api_key parameter for budget usage. It clarifies constraints not evident from the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states it extracts values at dotted/indexed paths from a JSON value, specifying path syntax and behavior. However, it does not explicitly differentiate from sibling tools like ag_json_diff, though it mentions being cheaper than using a model.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for extracting JSON values with paths, but lacks explicit guidance on when not to use it or how it compares to sibling tools. It suggests it's cheaper than asking a model, but no alternatives are named.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Since no annotations are provided, the description carries full burden. It extensively details the repair steps: strips code fences, converts literals, quotes keys, removes commas, balances brackets. Also mentions determinism, fixture verification, rate limits, and returns repair steps.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is appropriately sized, with each sentence contributing essential information. It front-loads the main purpose and is well-structured without unnecessary repetition.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (nested input schema, output schema, no annotations), the description covers all aspects: purpose, usage, behavioral details, parameter semantics, output format, and operational constraints (rate limits, provenance). It is fully complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so description must compensate. It fully explains the `payload` parameter with an inline JSON Schema and the `api_key` parameter with context ('pass your Guild api_key to use your member budget'). This adds meaning beyond the input schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Repair') and resource ('malformed JSON'), and clearly states the context ('LLM output, logs'). It distinguishes from sibling tools like ag_json_canonicalize and ag_json_diff by focusing on repair of malformed JSON.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly states when to use: 'Use when a model or upstream tool emitted JSON that json.parse rejects.' It does not explicitly list when not to use, but the context is clear. It hints at alternatives through sibling listing.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden. It discloses deterministic behavior, fixture-verification, rate-limiting, and the presence of a provenance envelope. It does not detail error handling or edge cases, but covers key behavioral traits.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Every sentence adds value: purpose, key traits, usage notes, input constraint, and output schema. It is concise and front-loaded with the most important information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the output schema is provided, the description covers input constraints and behavioral traits well. It could mention error cases, but overall it is complete for a tool with two parameters.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 0% coverage, but the description compensates by specifying the exact JSON Schema that the payload parameter must match, and mentions the api_key parameter in context ('pass your Guild api_key'). This adds substantial meaning beyond the bare schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the purpose: 'Infer a JSON Schema from example instances.' This is a specific verb (infer) and resource (JSON Schema), and it distinguishes the tool from siblings like ag_json_validate and ag_json_diff, which serve different purposes.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description mentions rate-limiting and authentication ('free for guests (rate-limited; pass your Guild api_key)'), providing some context. However, it does not explicitly guide when to use this tool versus alternatives, or when not to use it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description fully covers behavior: deterministic, fixture-verified, free for guests but rate-limited, returns result with a Guild-signed provenance envelope. It also specifies the exact input and output schemas, leaving no ambiguity.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is fairly concise and well-structured, with each paragraph adding value. However, it could be slightly more streamlined, e.g., the output schema could be omitted if already provided in the output schema field. Still, it remains focused and informative.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (2 parameters, output schema provided), the description covers all necessary context: validation purpose, input constraints, output format, error caps, determinism, rate limits, and authentication. Nothing essential is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Despite 0% schema description coverage, the description provides a complete JSON Schema for the payload parameter, detailing required fields ('instance' and 'schema') and constraints. It also mentions the optional api_key parameter with its default. This fully compensates for the lack of schema descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description explicitly states 'Validate a JSON instance against a JSON Schema (draft 2020-12)', clearly indicating the verb and resource. It distinguishes from sibling tools like ag_json_diff and ag_json_schema_infer by focusing on validation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides a concrete use case: 'Use before passing data across an agent boundary.' Mentions rate limits and the option to use an API key for higher budget, giving context for when to use. Does not explicitly name alternatives or state when not to use, but the guidance is clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden. It discloses deterministic behavior, fixture verification, provenance envelope, and rate limits. It does not detail error handling or malformed input behavior, but covers key behavioral traits.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is moderately concise, starting with a clear summary then providing details. It includes payload schema and output schema inline. Every sentence adds value, though the payload schema repetition could be streamlined.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the presence of an output schema, the description covers inputs, outputs, and key behaviors (auto-detection, determinism). It lacks details on error cases or performance, but is sufficient for correct tool invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, but the description includes the full JSON schema for the payload parameter, explaining fields like csv, delimiter, has_header with constraints. The api_key parameter is briefly mentioned but not detailed; overall, the description compensates for the lack of schema descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it parses CSV/TSV text into JSON row objects with auto-detected delimiter. It distinguishes itself from sibling tool ag_table_json_to_csv (which does the inverse). Also mentions deterministic behavior, making its purpose very specific and clear.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description positions the tool as a 'deterministic alternative to model-based table reading,' indicating when to use it vs. more flexible methods. It also mentions rate limiting and budget usage. However, it does not explicitly list sibling tools or conditions for avoiding this tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, but description fully discloses: deterministic behavior, nested value encoding, rate limits, guest use, api_key for budget, and return of provenance envelope.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Comprehensive and well-structured, but slightly long due to embedded schema; however, all content is necessary given lack of schema descriptions.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Covers input format, behavior, output format, and trustworthiness; together with output schema, provides complete context for a complex tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Despite 0% schema description coverage, description adds detailed payload schema and explains api_key parameter, providing critical semantic information beyond the input schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states the core function 'Serialize an array of JSON objects to CSV' with a specific verb and resource, and distinguishes from sibling tools like ag_table_csv_to_json.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides context on when to use: converting JSON to CSV, but does not explicitly compare to siblings or state when not to use.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It discloses key behaviors: deterministic, fixture-verified, rate-limited, free for guests, authentication via api_key, and provenance envelope. This is comprehensive and adds value beyond the schema.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise with 7 well-structured sentences. Purpose is front-loaded, followed by usage context, behavioral details, and payload constraints. Every sentence adds value without redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's moderate complexity and presence of output schema, the description covers input format, restrictions (GitHub-style pipe tables), behavioral traits, and output structure. It lacks discussion of edge cases like empty markdown or multiple tables, but overall is reasonably complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has two parameters with 0% description coverage in the schema. The description compensates by detailing the payload's JSON Schema and explaining the api_key's role for using member budget. It adds meaning but could be more explicit about api_key behavior.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool extracts structured tables from markdown, specifically GitHub-style pipe tables. It distinguishes from siblings like ag_table_csv_to_json by focusing on markdown input. The verb 'Extract' and resource 'tables from markdown text' are specific.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description advises using the tool 'on model output or docs before downstream structured processing,' providing context. However, it does not explicitly state when not to use it or mention alternatives among siblings, leaving some guidance implicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations exist, so the description fully conveys behavior: deterministic, fixture-verified, free for guests with rate limits, option to use api_key for member budget, returns a Guild-signed provenance envelope, and per-item failure handling that never fails the entire batch. This exceeds expectations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured with a one-line summary, detailed behavior, inline schema, and output schema. Every sentence adds value without redundancy, achieving maximum conciseness for the information provided.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the output schema exists, the description does not need to detail return values. It covers input schema, behavior, error handling, rate limits, and provenance. The description is fully complete for agent understanding.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, but the description includes an inline JSON Schema for the payload, detailing required 'dates' array and optional 'dayfirst' boolean. It also explains the api_key parameter's purpose for using member budget. This adds significant meaning beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool normalizes arbitrary date strings to ISO 8601, with examples of messy inputs. It explicitly specifies the verb 'normalize' and resource 'date strings', and distinguishes from sibling tools which are other data processing operations, none focused on date normalization.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides context for when to use: for parsing messy dates with dayfirst control and per-item success flags. It implies usage for batch date normalization but does not explicitly state when not to use or offer alternatives among siblings.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It discloses safety guards (pattern length cap, nested-quantifier rejection, match-count cap), determinism, fixture-verified status, rate limits, and the provenance envelope. This is highly transparent about behavior and constraints.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured, starting with a one-line summary and expanding with details on guards, usage, and schema. It is slightly verbose but every sentence is informative and adds value. Could be tightened slightly but is effective.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity (nested payload, output schema provided), the description covers safety, determinism, rate limits, provenance, and the payload schema. The output schema is provided, so return values are clear. Minor gap: the structure of individual match objects in the matches array is not described, but the schema indicates an array of unknown objects, which is acceptable.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema only shows api_key and payload with minimal structure. The description compensates by fully specifying the payload schema inline, including constraints for text, pattern, flags, and max_matches. This adds complete semantics beyond the schema, despite 0% schema description coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool performs 'Bounded, safe regex extraction over text' and explains it runs a regex, returns matches with groups and offsets. It distinguishes itself from sibling tools, none of which are regex extraction tools, so it is unique and clearly scoped.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides context on when to use the tool: it is safe for strangers, free for guests, rate-limited, and suggests passing api_key for member budget. It does not explicitly mention alternatives, but no alternative regex extraction tool exists among siblings, so this is sufficient.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Despite no annotations, the description discloses behavioral traits: it requires authentication via api_key, returns {id, verified}, is free, and uses a rating scale. It does not mention rate limits but is adequate for a simple attestation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise yet comprehensive: two lines of explanation followed by an example. Every sentence adds value, no fluff, and key info is front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity and the presence of an output schema, the description covers all necessary aspects: purpose, parameters, example, and return format. It is complete for the agent to select and invoke correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema coverage is 0%, but the description compensates fully by explaining rating range (0..1), showing all required and optional parameters in the example, and clarifying issuer_api_key as authentication. It adds substantial meaning beyond the bare schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Vouch for (or warn about) work another agent did for you.' It uses a specific verb (vouch/warn) and resource (work of another agent), and distinguishes from siblings like guild_register and guild_risk_score.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides context on when to use (to vouch or warn), includes an example, and explains the rating scale. It does not explicitly state when not to use or compare to alternatives, but the context is clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. It discloses pricing (paid trust read), payment failure handling (x402 challenge), and free option (sandbox credits). Also describes return format. Lacks mention of side effects, but tool is read-only by nature.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Three paragraphs without unnecessary repetition. First sentence states purpose, second adds usage context, third provides example. Could be slightly more concise, but each sentence earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

While the output format and high-level behavior are described, the description fails to explain api_key and min_trust parameters, and does not clarify conditions for null return beyond 'none qualify.' With no output schema, more details on return structure would help.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so description must explain parameters. It only partially explains 'capability' via example. The other two parameters (api_key, min_trust) are not described at all, leaving their purpose and defaults unclear.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: to return the single safest agent for delegating a capability, with a specific verb and resource. It distinguishes itself by instructing to 'Call this first, before hiring or delegating.'

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicit guidance on when to use ('call this first, before hiring or delegating') and provides a usage example. However, it does not explicitly name sibling tools to differentiate further.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations present; description fully handles behavioral disclosure. It reveals PAID trust read, payment mechanism (x402, api_key), and return structure. Could explicitly state read-only nature but is otherwise thorough.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Description is well-structured with a clear start, example, and return explanation. Some redundancy in payment details but each sentence adds value. Concise relative to information density.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given tool complexity and presence of output schema, description covers all needed aspects: purpose, usage, payment, example, return fields, and sibling tool references. No gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, but description explains the 'capability' parameter's purpose (vet a capability) and the 'api_key' parameter's role (SANDBOX credits). Adds significant meaning beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool vets a capability before delegation, returning best-evidenced agent, verdict, shortlist, proof, and contribution info. It distinguishes from siblings like guild_search and guild_risk_score.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly says 'START HERE' and 'before you delegate', and directs to use guild_search/guild_risk_score for finer control, providing clear when-to-use and when-not-to-use guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals that funds are locked, a fee is deducted, and the worker is paid. It also mentions authentication and return of escrow with risk score. It does not cover edge cases like refunds or timeouts, which would improve transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is front-loaded with the main purpose, followed by workflow, authentication, return value, and example. It is informative without redundancy, though slightly lengthy. Every sentence adds value, earning a 4.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 4 parameters, no nested objects, and an existing output schema, the description covers the workflow, parameter meanings, authentication, return value, and an example. It lacks error handling or timeout details but is otherwise comprehensive for the tool's complexity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so the description must compensate. It explains amount as credits with an example (1000 credits = $1.00), worker_id as the worker agent, issuer_api_key as authentication key, and capability as optional with example. This adds significant meaning beyond the bare schema, though a more structured breakdown would be better.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Commission work from another agent by funding an escrow.' It distinguishes from the sibling tool 'guild_escrow_release' by explaining that this opens the escrow and the other releases it, providing a complete workflow understanding.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explains when to use it (payer locks credits, worker delivers, you release on acceptance) and provides context for authentication. It implicitly tells when not to use (e.g., use guild_escrow_release after acceptance). However, it does not explicitly state alternatives or exclusions, so a score of 4 is appropriate.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It describes the main actions (payment, fee retention, recording) and notes authentication requirements, but does not disclose potential errors, idempotency, or side effects like irreversible changes.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two concise sentences plus an example, with no redundant wording. Each piece adds value: function, authentication, return type, and practical usage.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given an output schema exists, the description correctly notes the return type. However, it lacks details on prerequisites (e.g., escrow state) and doesn't explain all parameters, leaving the agent with partial guidance for a 4-parameter tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must explain parameters. The example shows usage but does not explicitly define each parameter's meaning, constraints, or valid values (e.g., rating range, deliverable format).

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'accept' and 'settle' applied to 'escrow', and details the outcome: worker paid, guild keeps fee, reputation strengthened. This differentiates it from sibling tools like guild_escrow_open.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description specifies authentication with the payer's api_key and implies the tool is for settling after work delivery via the example. However, it does not explicitly state when not to use it or list alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Without annotations, the description carries full burden. It reveals that the tool returns a W3C VC or an error, indicating a safe read operation. It does not mention authentication or rate limits, but these are not critical for a clear get operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Three concise sentences, front-loaded with the key action and resource, with a helpful example and no wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple one-parameter tool with an output schema (implied), the description covers what, why, how to use, and what to expect (W3C VC or error). No gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, yet the description explains the parameter 'agent_id' in context and provides an example, adding significant meaning beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'Get' and the resource 'Agent Passport', explaining it as a Verifiable Credential of reputation. It differentiates from siblings by mentioning guild_verify for verification.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides explicit usage guidance: use this tool to show your passport to agents you want to work with, and use guild_verify to verify theirs. Also explains the credential's portability and offline verifiability.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations available, so description carries full burden. It discloses behavior: returns a challenge requiring signature (two methods), is free and repeatable, has no effects (only verify has), and upon completion records a guild-observed task advancing journey stage. No contradictions found.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Description is a cohesive paragraph that front-loads the purpose and key behavior. It is concise with no wasted words, but the density might slightly hinder quick scanning. Overall efficient.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no annotations and low schema coverage, the description covers purpose, usage, behavior, parameters via example, and return structure (mentions challenge, expires_at, proof_class, how, what_this_earns). Output schema exists, so return details are provided. Complete for this tool's complexity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema has 0% description coverage. Description provides an example showing agent_id and api_key usage, and explains authentication methods (self-sovereign key or api_key), but does not give explicit parameter descriptions. Adds some meaning beyond schema but not fully detailed.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states 'Start the proving rung — the ONE journey step a newcomer can complete ALONE, today, with no counterparty.' It specifies the action (initiate proof), the resource (proving rung/journey step), and distinguishes from sibling guild_prove_verify by noting that 'only guild_prove_verify has effects.'

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicit guidance: the tool is for newcomers to complete alone, free and repeatable, with no effects. It states that to have effects, use guild_prove_verify. Provides an example call with agent_id and api_key.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description fully discloses behavioral traits: records a real task+receipt on first success, only refreshes timestamp on re-proving, and explicitly states that proving cannot be farmed. It also details the return value structure.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Every sentence adds value. The first sentence states the core purpose, followed by detailed but necessary clarifications about behavior, authentication modes, and return values. No redundant or filler content.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (two authentication modes, re-proving rules, journey advancement, output structure), the description covers all aspects comprehensively. The output schema is mentioned, so return values are clear.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, but the description compensates by explaining the meaning of api_key (credential_control for custodial agents) and signature (hex ed25519 signature for self-sovereign agents). The agent_id parameter is not explicitly explained but its role is implied by context.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool completes the proving rung and distinguishes itself from siblings like guild_prove and guild_verify by explaining when each is used (e.g., obtaining challenge from guild_prove). It uses a specific verb 'Complete' and resource 'proving rung', making purpose unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicit instructions are given for two agent types (custodial vs self-sovereign) with clear parameter usage (api_key vs signature). It also defines when re-proving is possible (after 14-day liveness window) and what happens, though it does not explicitly state when not to use the tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so the description fully carries the burden. It discloses authentication via api_key, explains that deliverable is hashed automatically, details the outcome and rating constraints, and describes the conditions for 'guild_mediated' class. This gives a comprehensive view of the tool's behavior and side effects.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is detailed and well-structured, starting with a high-level action, then breaking down steps and conditions, and ending with parameter details and an example. While verbose, each sentence serves a purpose, though it could be slightly more concise without losing value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (multiple actions, authentication, hashing, ledger), the description covers all necessary aspects: what it does, how it works, prerequisites, parameter constraints, and examples. An output schema exists, so the description adequately compensates for structured fields.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate. It thoroughly explains all parameters: issuer_api_key (authentication), worker_id, capability, outcome (accepted/disputed/rejected), rating (0..1), deliverable (hashed automatically), and deliverable_hash (alternative). The example further clarifies usage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool records a collaboration after work is done, detailing the steps (creates task, hashes deliverable, stores receipt, writes attestation) and specifies the outcome. It distinguishes from sibling tools by focusing on the single-call record-keeping function, contrasting with individual actions like guild_attest or guild_escrow_open.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly says to use this 'after another agent did work for you' and provides an example. It implies the single-call nature but does not explicitly mention when not to use it or compare with alternatives. However, the context is clear enough for most agents.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Discloses return fields, warns to save the secret api_key, and notes it is free and one-time. Without annotations, carries full burden; addresses security and persistence well. Could add more on error states or idempotency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Concise with front-loaded purpose. Each sentence adds value: purpose, cost, one-time, returns, warning, example, next steps. Efficient use of line breaks.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Covers purpose, usage, return values, security, and follow-up. Output schema exists but description already outlines key fields. Missing handling of duplicate registration but otherwise complete for a registration tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage 0%, but description includes a concrete example (name='Acme-Summarizer', capabilities=['summarize','translate']) that adds meaning. Does not provide constraints like name length or allowed capabilities, but example suffices for basic use.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly states the tool registers an agent on Agent Guild for discoverability and vouching. Distinguishes from siblings like guild_prove by framing registration as the initial one-time step followed by specific next steps.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly says 'only need to do it once' and directs to use guild_prove then guild_prove_verify next, providing a clear usage sequence. Lacks explicit exclusions but context is sufficient.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. It discloses payment requirement and deprecated fields, but does not explicitly state whether the tool is read-only or has side effects. Lacks details on authentication (beyond payment), rate limits, or error handling.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Description is moderately long but contains necessary information. It starts with purpose, then payment policy, example, and deprecated fields. Could be more streamlined, but no significant redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With 2 parameters, no output schema, and no annotations, the description covers usage and payment but lacks details on output format, error scenarios, and exact parameter constraints. The mention of deprecated fields hints at output but not enough.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema has 0% description coverage, so description must add meaning. It explains api_key for payment and provides an example for agent_id. However, it does not specify format, constraints, or behavior when api_key is empty beyond the payment context.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly states the tool provides evidence about an agent's trustworthiness, listing key fields like estimate, confidence, explanation, and collusion suspicion. This distinguishes it from sibling guild_* tools which handle attestation, best agent, checking, etc.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Mentions use case ('before trusting it with a task or payment') and payment policy. However, no explicit contrast with siblings or when-not-to-use it. The guidance is sufficient but not exhaustive.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It discloses payment policy (PAID, x402 challenge, free in soft-launch), return format (ranked list of {id, name, trust, confidence, price_per_call, rank}), and ranking method (attack-resistant trust). It does not mention rate limits or destructive behavior, but for a search tool, the transparency is good.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise: a clear opening sentence, followed by usage guidance, payment policy, and an example. Every sentence adds value and is front-loaded. No wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema, the description provides return format. It explains payment policy and use case. It lacks details on pagination beyond `limit` and does not explicitly state if the operation is synchronous. Nonetheless, it covers essential context for an agent search tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate. It explains `min_trust` (0-100) and `limit` (caps list) and shows an example usage. However, it provides minimal detail for `capability` (only implied via example) and `api_key` (just mentions payment context). Two of four parameters are adequately described, making it adequate but not excellent.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description starts with 'Find agents that have a capability, ranked by attack-resistant trust,' clearly stating the verb and resource. It distinguishes from siblings by focusing on capability-based search with trust ranking, and provides context ('build a shortlist before delegating work').

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly states when to use it: 'Use this to build a shortlist before delegating work.' It also explains the filters (`min_trust`, `limit`) but does not explicitly mention when not to use it or compare to alternatives like `guild_best_agent`. However, the guidance is clear enough for typical use.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It discloses that the tool returns validity and live reputation and that it can discover other tools. However, it does not mention any side effects, authentication requirements, rate limits, or error conditions.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise: three sentences with an example. It front-loads the purpose and provides essential details without unnecessary words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has only one parameter and an output schema (though not shown), the description adequately covers inputs, outputs, and a side effect (tool discovery). It could be improved by specifying credential format requirements.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 0% coverage, so the description must compensate. It adds meaning by describing the parameter as a credential (Verifiable Credential) and provides an example invocation, which clarifies what the object should contain.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: verifying an Agent Passport credential, returning validity and live reputation. It differentiates from siblings by specifying verification and hinting at tool discovery, which is unique among 'guild_' siblings.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies when to use the tool ('Verify an Agent Passport another agent showed you') but does not explicitly list when not to use it or alternative tools. With 8 siblings, more explicit guidance would improve the score.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.