agent-bank

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

Without annotations, the description partly discloses behavior by stating the reputation and CC reward and the commitment to deliver. However, it lacks details on irreversibility, failure or fulfillment process, 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?

Two sentences, front-loaded with the action, then the reward. No 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 no output schema and 3 parameters, the description covers purpose and reward but omits expected return, how to obtain barter_id, and prerequisites. Adequate but incomplete.

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 100% and the description adds no extra meaning to the parameters beyond what the schema already provides. Baseline score applies.

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 action (accept) and the resource (barter offer), and distinguishes from siblings like accept_swap and create_barter_offer. It also mentions the reward of reputation and CC.

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 this tool is for offerees to accept a barter offer, but does not explicitly state when to use it versus alternatives like create_barter_offer or confirm_barter_delivery. It mentions the reward but no exclusions.

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 should disclose side effects, idempotency, or state changes. It only mentions authentication ('Requires api_key'), omitting details like whether the swap is immediately executed or requires further 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 a single concise sentence that is front-loaded. However, it could be slightly more informative without becoming verbose.

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?

The tool has no output schema, and the description does not explain return values, error conditions, or behavior when the swap is invalid or already accepted. This leaves an agent without sufficient context to use the tool reliably.

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 100% with adequate parameter descriptions. The description adds no new semantic value beyond the schema, meeting the baseline expectation.

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 action 'accept' and the resource 'open P2P token swap offer', distinguishing it from siblings like 'accept_barter' or 'create_swap'. However, it does not elaborate on the implications of acceptance.

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?

No guidance on when to use this tool vs. alternatives (e.g., 'accept_barter'). The mention of 'Requires api_key' is a prerequisite, not usage context.

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 must disclose behavioral traits. It states the tool is AI-driven and requires no API key, which hints at safety. However, it does not detail side effects, data usage, or whether the analysis is read-only, leaving gaps for a tool with no annotation support.

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 sentences, front-loaded with core purpose and types. Every phrase adds value with no redundancy or filler.

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 lack of an output schema, the description adequately conveys the input type and outcome (risk/reward assessment). It is complete enough for an agent to understand when to invoke it, though more detail on the output format could 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 coverage is 100%, so parameters are already documented. The description adds value by noting 'No api_key required,' which clarifies that agent_id is truly optional and not needed for basic use. This semantic hint goes beyond the schema's optional marker.

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 analyzes a financial opportunity (job, swap, loan, or service) and provides an AI risk/reward assessment. The verb 'Analyze' and the resource 'specific financial opportunity' are specific, and listing the types distinguishes it from sibling action tools like accept_barter or borrow.

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 'before committing,' indicating the tool is for pre-decision analysis. This gives clear context, though it does not explicitly mention when not to use it or name alternatives among siblings. The implicit guidance is strong.

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 mentions 'no api_key required' but does not state whether the tool is read-only, has side effects, or any rate limits. For an assessment tool, more behavioral context would be helpful.

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 efficient sentences with no extraneous information. Highly concise and clear.

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?

Missing output description and any return format. While parameter is simple, lack of output schema or return value info limits completeness for agent decision-making.

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?

Only one parameter with full schema coverage. Description adds no additional semantic value beyond the schema description. Baseline score of 3 is appropriate.

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 verb 'assess', resource 'CBC credit limit', and basis 'reputation and earning history'. It also notes authentication requirement, distinguishing it from siblings like borrow or get_cc_credit.

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?

No explicit when-to-use or alternatives mentioned. The note about no api_key hints at a lower barrier, but no guidance on when to choose this vs other credit-related tools.

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 must carry full burden. Mentions 'reputation-based collateral' and 'auto-selects USDC pool' but omits important traits like potential failure modes, collateral locking, or response format. Does not disclose if the tool mutates state or requires specific permissions.

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 sentences, no fluff, front-loaded with key action. Could be more structured (e.g., bullet points) but efficient for 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?

For a tool with 6 parameters, no output schema, and no annotations, the description is too brief. Missing details on return values, error handling, prerequisites (e.g., agent reputation), and how the USDC pool auto-selection works. Does not help agent select among many sibling tools.

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 100%, so each parameter is described in the schema. The description adds context about collateral and pool selection but does not enhance individual parameter meanings. Baseline of 3 is appropriate as description provides marginal extra value.

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 verb 'borrow' and resource 'LendingPool' with specific details (reputation-based collateral, auto-selects USDC pool). However, does not distinguish from sibling tools like borrow_cc or borrow_capability, which could cause ambiguity.

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?

No guidance on when to use this tool vs alternatives. Mentions requirement of api_key but does not specify context or exclusions. Sibling list includes other borrowing tools, but description offers no comparative advice.

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 but only says 'Borrow tokens... Requires api_key.' It does not disclose what CBC means, whether the operation is destructive, rate limits, or other behavioral traits 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 very short, which is efficient, but it lacks structure and does not front-load key information. It is not verbose but may be too minimal for full understanding.

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, five parameters, and no annotations, the description should provide more context about return values, error handling, and behavioral nuances. It is insufficient for an agent to fully utilize the 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?

Parameter schema has 100% description coverage, so baseline is 3. The description adds no further parameter meaning beyond what is already in 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 action (borrow), resource (tokens against future earning potential), and acronym CBC which distinguishes it from siblings like borrow and borrow_cc.

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 only mentions a requirement (api_key) but provides no guidance on when to use this tool versus alternatives such as borrow or borrow_cc. No when-to or when-not-to context.

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. Discloses borrowing against reputation, no collateral, auto-repay from earnings, and api_key requirement. Fails to disclose interest rates, default consequences, or tier limits beyond what's in schema. Partial but not comprehensive.

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 sentences and a short note. Extremely concise with no redundancy. Front-loaded with main purpose and key details.

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?

Lacks output format, return values, error conditions, interest rates, and repayment details. For a financial tool without output schema or annotations, description should provide more context to set expectations about side effects and results.

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 100%, reducing need for description. Description adds denomination context (1 CC = 10,000 cogs) which aids understanding of 'amount_cogs'. Repeats api_key requirement but adds no new meaning for other parameters.

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 borrows Capability Credits against reputation with no collateral and auto-repay. It specifies denomination (1 CC = 10,000 cogs). Differentiates from generic 'borrow' sibling by mentioning reputation and auto-repay, but could explicitly distinguish from other CC borrowing tools like 'borrow_capability'.

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?

Implies usage for reputation-based borrowing with auto-repay, but no explicit guidance on when to use this versus sibling tools like 'borrow' or 'borrow_capability'. Missing when-not-to-use or 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 are provided, so the description carries the full burden. It discloses that jobs are sorted by profitability, and what each job entry contains (pays, cost, profit, verdict). It implies a read-only browse operation, but does not explicitly state it is non-destructive. Adding 'read-only' would make it a 5.

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 sentences, front-loaded with the core purpose, then detailing output and prerequisite. Every sentence adds value with 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 and no annotations, the description adequately explains the output fields, sorting order, and prerequisite. However, it does not cover error conditions or edge cases (e.g., what happens if cost profile is not set). For a browse tool, this is sufficient.

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 67%, with 'limit' and 'task_type' having descriptions in the schema. The description does not add any additional meaning beyond the schema; it does not explain 'agent_id' (required) or clarify parameter constraints. It adds value by mentioning the prerequisite but not parameters.

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 'browse open CC jobs' with a specific resource (CC jobs) and verb (browse). It distinguishes from siblings like 'list_open_jobs' by adding 'enriched with personalised accept/reject signals'. The output is detailed, including profit margin and verdict.

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 guidance to 'Set your cost profile first with set_cost_profile', indicating a precondition. It implies usage when personalized economics are needed, but does not explicitly state when not to use it or compare with 'list_open_jobs' or 'find_matching_jobs'.

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 that escrowed CC is returned for sell orders, a useful behavioral trait. However, no annotations exist, so description carries full burden; it lacks details on error handling or security (e.g., role of API key).

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 sentences, no filler. Front-loaded with action and resource, then adds condition for sell orders. Every 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?

Adequate for a simple cancel operation given no output schema, but missing error scenarios, response format, and prerequisites (e.g., order ownership). Could be improved with minimal extra context.

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% and description does not explain any parameters beyond implying order_id. API key and agent_id are completely undescribed, leaving the agent without guidance on what values to provide.

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?

Clear verb 'cancel' and specific resource 'open or partially filled CC/USDC order'. Distinct from sibling tools like place_cc_order and fill_cc_order.

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 for when to cancel (open or partially filled) but no explicit when-not or alternatives. Implies usage but no guidance on choosing this tool over others.

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 that no API key is required, which is useful auth info. However, lacks details on response format, rate limits, or that it's read-only/non-destructive. Without annotations, more behavioral context would help.

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 sentence that is efficient and front-loaded with the verb and purpose. No 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?

For a simple chat tool with 2 parameters and no output schema, the description covers purpose and auth. Could mention return format, but it's adequate for decision-making.

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 100% with both parameters described in the schema. The description adds no extra meaning beyond the schema. Baseline 3 is appropriate.

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 action (ask questions) and the resource (AI concierge), and specifies domains (platform, APIs, smart contracts, features). It distinguishes from sibling tools, which are transactional/financial.

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?

Implicitly indicates use for Q&A, but no explicit guidance on when not to use or alternatives. Given sibling tools are action-oriented, it's clear this is for queries, but not stated.

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 must carry full behavioral burden. It discloses the outcome (both confirm -> completion + rewards) and requirement (api_key), but does not cover edge cases like first confirmation or cancellation.

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 sentences that efficiently convey the action, outcome, and requirement. No redundant 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?

Covers purpose and reward, but lacks mention of constraints like agent being a participant in the barter. Reasonable completeness given tool simplicity and no 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 100% with a description for each parameter. The tool description adds no new semantic value beyond restating the deliverable type, so baseline score of 3 is appropriate.

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 action: 'Confirm you have delivered your side of a barter.' It distinguishes from siblings like accept_barter or create_barter_offer by specifying the confirmation step after delivery.

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 after delivering a barter, but does not explicitly guide when to use this tool versus alternatives (e.g., accept_barter, list_barter_offers). No when-not-to-use or alternative tool references.

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 must disclose behavioral traits. It fails to mention what happens after creation (e.g., offer is listed, can be accepted), leaving the agent unaware of lifecycle or 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?

Three concise sentences front-load the core purpose and key constraints. No filler or redundant information, earning its space.

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?

No output schema exists, yet the description omits return value (e.g., offer ID). While it covers prerequisites and purpose, it lacks completeness for an agent to fully anticipate the result of 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 coverage is 100%, so descriptions add minimal new info. The example 'e.g. 'research-report'' adds minor value, but overall the tool description does not significantly enhance parameter understanding 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 'Offer your capabilities in exchange for another agent's capabilities' and specifies 'No USDC required — pure skill-for-skill barter', making the purpose distinct from sibling tools like create_swap or accept_barter.

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 'Perfect for new agents with no balance' and 'Requires api_key', providing context on when to use. However, it does not explicitly differentiate from similar tools like create_swap or warn about 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 carries full burden. It reveals authentication need and the negotiable-job pattern, but omits important behavioral traits: on-chain costs (gas), reversal conditions, or what happens on failure. The agent is left guessing about 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?

Three short sentences deliver all key information with no redundancy or unnecessary detail. Every sentence adds value: action, negotiable hint, and auth requirement. Extremely 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 the complexity (smart contract, 6 params, no output schema), the description lacks detail on immediate effects (e.g., gas fees, on-chain confirmation), return values (e.g., job ID), and deadline format constraints. It covers the basics but leaves gaps for an agent to handle 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?

Schema covers all 6 parameters (100% coverage). The description adds value by clarifying the negotiable amount pattern and emphasizing the api_key requirement. This extra context is helpful but not critical since schema already describes each 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 specifies the action ('Create'), the resource ('service-for-crypto escrow job'), and the technical method ('via the ServiceEscrow smart contract (ERC-8183)'). It distinguishes this tool from siblings like 'accept_barter' or 'create_swap' by naming the specific contract and job type.

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 hint ('Set amount=0 for negotiable jobs') and a prerequisite ('Requires api_key'). However, it does not mention when to use this tool vs. siblings like 'negotiate_job' or 'browse_jobs_with_economics', leaving some ambiguity for the agent.

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 only states 'Requires api_key' which is already in schema, but fails to disclose important behavioral traits like gas costs, confirmation time, or error handling. Lacks detail for a mutation tool.

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 one sentence plus an essential note. It is front-loaded with the main action. However, it could be slightly improved with more context without becoming verbose.

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 6 required parameters, no output schema, and no annotations, the description is too brief. It does not explain return values, error states, or prerequisites (beyond api_key). Incomplete for a complex mutation 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 100%, so parameters are well-documented in the schema. The description adds minimal meaning beyond the schema (only mentioning api_key). Baseline of 3 is appropriate.

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 'create', the resource 'P2P token swap offer', and the context 'on the P2PSwap smart contract'. It distinguishes from siblings like accept_swap and cancel_cc_order.

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 does not provide guidance on when to use this tool versus alternatives (e.g., accept_swap) or any prerequisites beyond api_key. No exclusions or use cases are mentioned.

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 bears full responsibility. It reveals return types but not how the estimate is computed, whether it uses market rates, or assumptions. The CWU line adds irrelevant and unexplained information.

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?

Short but includes an irrelevant, unexplained line about CWU that distracts. Front-loads purpose well but the extra line harms conciseness.

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?

No output schema, so description should explain return values more thoroughly. Does not mention how estimation works, assumptions, or limitations. The CWU line is incomplete and irrelevant.

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 covers 100% of parameters with descriptions. The description adds nothing beyond the schema, so baseline 3 is appropriate.

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 it estimates the payment in cogs/CC for a task, specifying when to use (BEFORE posting a job or accepting an offer). The irrelevant CWU line is confusing but does not obscure the core purpose.

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 mentions 'Use BEFORE posting a job or accepting an offer.' No alternative tools are mentioned, but the context makes the usage 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 discloses taker action, trade direction, and partial fills. It lacks detail on auth needs, error states, or idempotency, providing only basic behavioral 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 sentences plus one line, each adding distinct value: main action, buy/sell explanation, partial fills. No filler text, and front-loaded with the primary purpose.

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 4 parameters, no output schema, and no annotations, the description explains the action but omits response format and prerequisites. Adequate but not comprehensive for robust 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 50% (only order_id and fill_cogs described). The description adds no information about api_key or agent_id, failing to compensate for missing schema details.

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 fills an existing open order on the CC/USDC book as a taker action, with specific buy/sell behaviors. It distinguishes from sibling tools like place_cc_order (creates) and cancel_cc_order (cancels).

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 context by stating 'Fill an existing open order' and mentions partial fills. However, it does not explicitly state when not to use or compare to alternatives like creating a new order.

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 carries full burden. Mentions no API key needed but omits details on matching algorithm, read-only nature, pagination, 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?

Two sentences, front-loaded with purpose, no redundancy. Every word 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?

Adequate for a simple search tool with 2 params and no output schema. Lacks details on output format, sorting, or potential errors, but covers core purpose.

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 100%, so baseline is 3. Description adds value by explaining that 'capabilities' defaults to agent's registered capabilities, clarifying behavior beyond 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?

Clearly states verb 'Find', resource 'jobs', and the key differentiator 'matching your agent's specific capabilities'. Distinguishes from browsing all jobs, implying a targeted search.

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 contrasts with 'browsing all jobs', suggesting when to use this tool. Mentions 'No api_key required' as a usage condition. Could be more explicit about alternatives like 'browse_jobs_with_economics'.

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 that no api_key is needed and lists returned data fields, but lacks details on rate limits, performance, or any side effects. Adequate but not comprehensive.

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. The first sentence clearly states the purpose and lists returned fields. The second adds a key usage note. Every sentence earns its place with no fluff.

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?

No output schema, but description explicitly lists the major data categories (reputation, wallet, capabilities, completed jobs, transaction history). This is sufficient for an agent to understand the result shape. Missing details like pagination or timestamps, but acceptable for a profile endpoint.

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 100% with a description for agent_id ('UUID of the agent to look up'). The tool description does not add further meaning beyond this, so baseline score of 3 is appropriate.

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 gets a complete profile for any agent, listing specific fields (reputation, wallet, capabilities, completed jobs, transaction history). The verb 'get' and resource 'agent_profile' are specific. Sibling tools like get_balance or get_transaction_history are distinct, as they retrieve subsets of data.

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 'No api_key required', hinting at ease of use, but does not explicitly state when to prefer this tool over alternatives like get_balance or get_transaction_history. Usage context is implied but not clearly defined.

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. It correctly implies a read operation via 'Get', and the note about no API key is helpful. However, it does not disclose potential side effects (unlikely), rate limits, or data freshness, which would strengthen 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 extremely concise: one sentence stating the action and a second brief note. Every word adds value, and the key information 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?

For a simple tool with one parameter and no output schema, the description covers the basics: what it does, which tokens, and authentication. However, it does not describe the response format or any example, which would improve completeness.

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 100% (agent_id is described as 'UUID of the agent'), so the description adds no additional meaning beyond the schema. Baseline score of 3 is appropriate.

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 action (Get), the resource (an agent's on-chain token balances), and specifies the tokens (USDC, WMATIC, WETH, MATIC). It effectively distinguishes from siblings like get_cc_balance by focusing on on-chain tokens.

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 a clear context for use (querying on-chain token balances) and a notable guideline (no API key required). However, it does not explicitly state when not to use this tool or contrast it with alternatives such as portfolio_summary or get_cc_balance.

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. Declares 'No api_key required' as a key behavioral trait and specifies return fields. Does not disclose read-only nature, 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?

Extremely concise: two sentences that front-load purpose and key details (conversion, return fields, auth). 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 one parameter, no output schema, and no annotations, the description adequately covers what it does and returns. Misses elaboration on 'transaction stats' but overall sufficient for low 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 100%, so baseline is 3. Description adds no extra meaning beyond the schema's 'UUID of the agent' for the only parameter (agent_id).

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 it retrieves Capability Credit balance in cogs, specifies conversion rate (1 CC = 10,000 cogs), and mentions returns of balance_cogs and balance_cc. Differentiates from siblings like get_balance and get_cc_credit by focusing on CC balance with cogs conversion.

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?

Implies usage for checking CC balance but does not explicitly state when to use this tool over siblings like get_balance or get_cc_credit. No guidance on prerequisites or scenarios.

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?

Provides units (cogs) and states no API key required, but does not confirm it is read-only or disclose any side effects. Lacks explicit behavioral details.

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 sentences, but the second sentence about CWU is irrelevant and adds noise. Could be more concise by omitting extraneous 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?

Adequate for a simple check tool, but missing behavioral details like read-only nature. The mention of 'how to increase borrowing power' is vague.

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 covers the only parameter (agent_id) with a description. The tool description adds no extra meaning beyond the schema, so baseline of 3 is appropriate.

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 checks CC credit limit and debt, distinguishing it from balance or history tools. However, it does not explicitly differentiate from 'borrow_capability' or 'assess_credit'.

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?

No guidance on when to use this tool versus alternatives like 'get_cc_balance' or 'assess_credit'. Only mentions 'No api_key required,' which is a precondition.

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 bears the burden. It discloses return format (cogs and cc) and authentication (no api_key), but omits details like pagination behavior, ordering, or whether results are chronological. Adequate but incomplete.

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 that front-load purpose, then provide key details. No wasted words, every 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 no output schema, the description explains return format adequately. It lacks explicit mention of list structure or ordering, but for a simple history retrieval tool, it is nearly 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 coverage is 100%, and the description adds no extra meaning beyond what the schema already provides. The amount format note is useful but not parameter-specific. Baseline 3 is appropriate.

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 retrieves CC transaction history, with specific verb 'Get' and resource 'your CC transaction history'. It also provides conversion details, distinguishing it from sibling tools like get_transaction_history.

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?

No explicit guidance on when to use this tool versus alternatives. The mention of 'No api_key required' implies a low-security requirement but lacks comparative context among the many related sibling tools.

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 indicates a read-only operation (Get) and mentions no authentication required, which is helpful. However, it does not disclose rate limits, data freshness, error modes, or other behavioral characteristics beyond the basic safety profile.

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 sentences: the first is a clear, front-loaded statement of the tool's function, and the second adds complementary context. Every word earns its place with no redundancy or filler.

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 parameters, no output schema, and no annotations, the description sufficiently covers what the tool does, what data it returns, and the fact that no API key is required. Nothing crucial is missing for a simple stats endpoint.

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 tool has zero parameters, so the baseline is 4 per the rubric. The description adds value by listing the returned stats (total supply, etc.), compensating for the lack of output schema. No further parameter documentation is needed.

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 it retrieves CC market stats (total supply, circulating supply, burn rate, implied USDC exchange rate). The description uses a specific verb ('get') and resource ('CC market'), and the tool is distinct from sibling tools like get_cc_balance or get_cc_history which focus on individual or transactional data.

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 notes that it tracks the health of the CC economy, suggesting its use for market health assessment. It also explicitly states 'No api_key required', which is a usage condition. However, it does not specify when not to use this tool or mention 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?

Without annotations, the description carries the burden. It discloses the data returned (bids, asks, spread, etc.) and that it's live. Missing details like polling behavior, rate limits, or response size, but adequately describes outcome.

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 well-constructed sentences with no redundancy. Front-loads the purpose and immediately explains return value. Every word 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?

The description explains the return structure (bids, asks, etc.) despite no output schema. The parameter is simple. Given the number of sibling tools, this description covers the necessary context for an informed call.

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 single parameter 'depth' is already described in the input schema (default 10, max 50). The description adds no extra semantic meaning beyond what the schema provides, so baseline 3 applies due to 100% schema 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 it retrieves the live CC/USDC order book with specific data (bids, asks, best bid/ask, spread, mid-price, recent fill history). It distinguishes itself from siblings like get_cc_market or get_market_depth by focusing on order book depth and pricing.

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 'Use this to find the best price before placing or filling an order,' providing clear when-to-use guidance. Does not mention when not to use or alternatives, but the context and sibling names imply this is the primary order book 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?

Describes live data, sorting order, and additional computed fields (revenue/margin). No annotations provided, so description carries full burden and does well.

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 sentences, no fluff, front-loaded with main purpose.

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?

No output schema, but description adequately sets expectations for what is returned. Good for moderate complexity 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 is 100% and description adds no new info beyond schema. Baseline score of 3 is appropriate.

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 it retrieves the live market order book with agents and prices sorted cheapest-first, including revenue/margin. Distinct from sibling tools like get_cc_orderbook.

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 suggests using for pricing listings or finding cheapest agent. No when-not-to-use but sufficiently guides agent.

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?

The description clearly states it is a read operation ('Get') and that it requires no authentication. This adequately conveys the behavioral trait of being a public, read-only endpoint. However, it lacks details on rate limits, data freshness, or scope of tokens/pools covered, which would enhance 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 two short sentences, each serving a purpose: stating the action and a key property (no auth). No verbosity or redundancy. It is optimally concise for a simple tool.

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 no parameters, no output schema, and no annotations, the description provides only the bare minimum. While it is clear, it could benefit from mentioning the return format or coverage (e.g., 'returns a list of token symbols and their current price in USD') to be fully complete for an agent.

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?

There are zero parameters, and the input schema is fully covered with no required fields. According to guidelines, 0 parameters warrants a baseline of 4. The description adds no extra param info, which is acceptable as none exist.

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 'Get' and clearly identifies the resources 'current token prices and lending pool rates'. It distinguishes from siblings like 'get_market_depth' which focuses on order book depth, and 'get_cc_market' which is for credit coin market data. The purpose is 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?

The description notes 'No api_key required', hinting at ease of use, but provides no guidance on when to use this tool vs alternatives like 'get_market_depth' or 'get_cc_market'. There is no mention of preconditions or typical scenarios for invocation.

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 present, so the description bears full responsibility. It discloses that the data is 'live' and lists what is retrieved, but does not mention behavioral traits like rate limits, caching, or side effects. For a read-only stats tool, this is minimally adequate.

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 extremely concise: two sentences that express purpose, data content, and an important access condition. Every word earns its place, with no redundancy or fluff.

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 no output schema, the description covers the essential aspects: purpose, data items, and authentication. It does not specify the return format (e.g., JSON), but the listed fields imply the structure. Overall, it is sufficiently complete for such a simple 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?

There are no parameters (schema coverage 100%), so the description adds value by clarifying that no api_key is needed. This surpasses the baseline of 3 by providing actionable context about authentication requirements.

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 identifies the tool's purpose: retrieving live platform statistics. It lists specific data points (total agents, transaction volume, etc.), distinguishing it from the many sibling tools focused on specific operations like barter, swap, or credit.

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 that no api_key is required, implying public access. While it doesn't specify when to use vs alternatives, the unique nature of the tool (platform stats) makes its context clear. No exclusion criteria are provided, but the simplicity and lack of similar siblings reduce need.

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 must carry full burden. It mentions pagination but lacks details on error handling, rate limits, data freshness, or what happens with invalid agent_id.

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 sentences, front-loaded with purpose. No wasted words, efficient and clear.

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 tool with 3 parameters and no output schema, description is minimal. Does not explain return values, error handling, or scope of 'unified activity', leaving gaps for an agent to use it 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?

Schema coverage is 100%, so baseline is 3. Description adds 'with pagination' which aligns with limit/offset parameters, but does not provide additional parameter semantics beyond what schema already offers.

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 it retrieves unified activity history (transfers, jobs, loans) with pagination for an agent. It is specific but does not explicitly differentiate from sibling tools like transfer_cc or get_balance.

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?

Only mentions 'No api_key required' which is a permission note, but no guidance on when to use this tool versus alternatives like get_balance or get_cc_history.

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 only adds 'No api_key required', which is a minor behavioral note. It does not disclose whether the operation is read-only, has side effects, or any other traits. More behavioral context is needed.

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 very short sentences, each conveying essential information. No wasted words. Front-loads the purpose and filtering capability.

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 listing tool with no output schema and no annotations, the description is too brief. It lacks explanation of response format, pagination, ordering, or what fields are returned. Agents are left with incomplete information to use the tool effectively.

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 100% with parameter descriptions. The description rephrases the capability_filter as 'what you can offer to them', adding useful context beyond the schema. 'No api_key required' is not parameter-related but still adds value.

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 clear verb 'Browse' and specific resource 'open barter offers from other agents'. It also notes filtering by capability, distinguishing it from sibling tools like accept_barter or create_barter_offer.

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 states 'Filter by the capability you can provide', giving a clear use case. However, it does not specify when not to use this tool or mention alternatives, which could be improved given the many sibling tools.

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 must disclose all behavioral traits. It only states no API key needed. It omits important details like pagination, sorting, default limit, and return format, leaving the agent uncertain about the tool's behavior.

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 extremely concise, with only two sentences that convey the core purpose and a key usage note. No filler or redundant 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 tool's simplicity (4 optional params, no output schema) and lack of annotations, the description is adequate but minimal. It could be more complete by mentioning default limit or response structure, especially since similar sibling tools exist.

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 100%, so the baseline is 3. The description adds no extra parameter context beyond what the schema already provides, such as clarifying the meaning of 'token' or the range of amounts.

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 browses available jobs needing providers, making the purpose obvious. However, it does not distinguish from similar sibling tools like browse_jobs_with_economics or find_matching_jobs, which could cause confusion.

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 'No api_key required,' giving a minor guideline, but provides no comparison or when-not-to-use instructions. With siblings like find_matching_jobs and browse_jobs_with_economics, the agent gets no guidance on selecting this tool over 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?

The description adds one behavioral trait: 'No api_key required', which is helpful for understanding access. However, with no annotations, more details are needed about return format, pagination, or side effects. The description is adequate but minimal for a read 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?

The description is two sentences, front-loaded with the purpose, and contains no unnecessary words. It is concise and 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 the lack of output schema and annotations, the description is too minimal. It does not explain the response structure, pagination behavior, or error handling, which are important for a tool with no annotations. Sibling complexity further highlights the need for more context.

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 100% and already describes all three optional parameters. The description does not add any additional meaning or context beyond what the schema provides, so baseline 3 is appropriate.

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 browses available P2P token swap offers, using a specific verb and resource. However, it does not distinguish this from sibling tools like 'list_barter_offers' which may have similar semantics.

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?

No guidance is provided on when to use this tool versus alternatives like 'list_barter_offers' or 'create_swap'. The description lacks context for when-not to use and does not reference any exclusions.

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 adds the key behavioral trait that no API key is required and implies a read-only operation. However, it does not disclose other traits like pagination behavior, rate limits, or what happens with no results.

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 extremely concise: two short sentences that clearly state the purpose and a key access note. Every sentence adds value with no 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?

For a simple browse tool with optional pagination and filtering, the description covers the core purpose and a key constraint (no API key). It lacks detail on the return format, but the tool's simplicity and the presence of parameter descriptions make it mostly 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 100%, with both parameters already documented ('Max results (default 20)' for limit, 'Filter by category (optional)' for category). The description adds no extra meaning beyond the schema, so baseline 3 is appropriate.

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 'Browse' and identifies the resource as 'the service marketplace' with the action of discovering offerings and prices. It clearly distinguishes from sibling tools like list_barter_offers and list_open_jobs by focusing on services generally.

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 states 'No api_key required,' which is useful but does not provide explicit guidance on when to use this tool versus alternatives such as list_barter_offers or list_open_swaps. The context is clear but lacks exclusions or comparisons.

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 must carry the burden of behavioral disclosure. It mentions the api_key requirement but does not disclose other traits like idempotency, error handling, or side effects. This is insufficient for a tool that creates and deletes resources.

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 extremely concise, consisting of one sentence and a fragment. It is front-loaded with the core purpose and contains no 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 six parameters, the lack of output schema, and the need to explain return values and error cases, the description is incomplete. It does not clarify how list works without an agent_id, what happens with invalid actions, or the format of responses.

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 100%, so the input schema already documents each parameter. The description adds little semantic value beyond reiterating the api_key requirement. It does not clarify parameter relationships or provide additional context that is not already in 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 registers, lists, or deletes webhook subscriptions for agent events, providing a specific verb and resource. It distinguishes from sibling tools, as none deal with webhook management. However, 'agent events' is somewhat vague and could be more 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 notes that api_key is required for register/delete actions, which gives some usage guidance. However, it does not provide when to use this tool versus alternatives (none exist) or exclude cases, leaving the agent to infer context.

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 must disclose behavioral traits. It only mentions the api_key requirement (already in schema) and does not state whether the operation is destructive, triggers notifications, or has 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 a single, front-loaded sentence with no extraneous words, efficiently conveying the core purpose.

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?

Despite 8 parameters and no output schema, the description is sparse. It omits the negotiation flow, success/error handling, and any prerequisites beyond api_key, leaving the agent with incomplete context.

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 100%, so baseline is 3. The description adds no parameter-level meaning beyond the schema; it does not explain relationships between action, counter_amount, and negotiation_id.

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: submitting a price negotiation proposal, counter-proposal, or accepting a negotiation for a job. The verb 'submit' and resource 'price negotiation' are specific and distinguish it from sibling tools like 'create_job'.

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 'create_job' or 'accept_barter'. It only mentions a requirement (api_key) but does not specify context, prerequisites, 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?

Discloses key behaviors: escrow/locking of funds, immediate auto-match, minimum amount. However, lacks details on order persistence, expiry, cancellation, or error conditions. With no annotations, this is moderate.

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 sentences: first sets purpose, next two explain order behaviors. Front-loaded, no filler, every 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?

Covers purpose, order types, and minimum, but missing details on return value (no output schema), balance requirements, order status after placement, and error handling. Adequate but not complete for a trading 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?

Adds marginal value beyond schema: explains order_type effects (SELL vs BUY) which schema also states, and repeats minimum amount. Schema coverage is 67%, so description does not fully compensate.

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 places a buy or sell limit order on the CC/USDC order book. The verb (Place) and resource (limit order) are specific, and it distinguishes from sibling tools like cancel_cc_order or fill_cc_order.

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 auto-matching and minimum amount, but does not explicitly state when to use this tool versus alternatives like fill_cc_order (market order) or cancel_cc_order. No 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?

No annotations are provided, so the description carries the full burden. It discloses that no API key is required, but does not mention data freshness, potential errors, or whether this is a read-only operation. The lack of destructive hints is acceptable for a read 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?

The description is two sentences, front-loaded with the core purpose, and each sentence adds value. No 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?

The description lists the key components of the summary (balances, loans, jobs, reputation, credit), providing adequate context for a retrieval tool. However, with no output schema, it could benefit from clarifying the structure or format of the returned data.

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?

Only one parameter (agent_id) exists, and its schema description already provides 'UUID of the agent'. The tool description adds no further semantic detail, so the parameter semantics score meets the baseline of 3 due to high schema 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 it retrieves a composite financial summary, listing specific components. It is distinct from sibling tools that focus on individual aspects like get_balance or get_cc_credit, but does not explicitly differentiate from them.

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 a quick dashboard overview and notes that no API key is required, but lacks explicit guidance on when to use this tool versus more specific alternatives like get_balance or list_open_jobs.

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 that the old key is deactivated (destructive behavior) and that the new key is valid for 90 days. This adds valuable behavioral context beyond the input 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?

Two sentences, front-loaded with the verb and resource. Every sentence provides essential information without redundancy. 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?

The description covers the purpose, return value, and side effects comprehensively for a simple tool. It does not specify behavior when the key is not expiring (e.g., whether it still works as a forced refresh), but this is a minor gap. No output schema, but the return value is described.

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 100% with both 'api_key' and 'agent_id' having descriptions. The tool description does not add any additional parameter-level information beyond what the schema provides. Baseline 3 is appropriate.

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 specifies the verb 'refresh' and resource 'API key', includes the condition 'if it's expiring', and states the return value (new api_key valid for 90 days) and side effect (old key deactivated). It clearly distinguishes from sibling tools, which are unrelated finance and trading operations.

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 the tool ('if it's expiring'), providing clear context. It does not mention alternatives or when not to use, but the condition is sufficient for this simple tool. No contradictions with sibling tools.

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. It reveals that registration yields a wallet address and api_key, and that the key is critical for subsequent operations. However, it omits potential side effects (e.g., irreversibility, uniqueness constraints) or rate limits, leaving some uncertainty.

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 concise sentences, front-loaded with the primary purpose. Every sentence contributes necessary information without redundancy or extraneous detail.

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?

Despite no output schema, the description explicitly states the outputs (wallet address and api_key) and their significance. It provides sufficient context for a registration tool, though it could mention parameter constraints (e.g., name uniqueness) for greater completeness.

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 100%, and the description does not add new information beyond the schema's parameter descriptions. The baseline score of 3 applies because the schema already documents the parameters adequately; the description adds no extra semantic value.

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 action 'Register a new AI agent' and specifies the outputs ('Polygon wallet address and api_key'). This distinguishes it from sibling tools (e.g., get_agent_profile, create_job) 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 advises saving the api_key and explains its role in authenticating financial operations, providing clear usage context. However, it does not explicitly state when not to use this tool or compare it to alternatives, though such guidance is less necessary for a unique registration action.

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 carries full burden. It discloses that the tool modifies visibility on the order book and returns a breakeven analysis, but does not specify whether it overwrites or appends, authentication requirements, or any destructive side effects. For a write operation, more transparency is needed.

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 sentences, no fluff. Could be improved with structured formatting (e.g., bullet points) but remains clear and 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?

Despite mentioning return value, the description fails to describe required top-level parameters and the nested array structure. No output schema exists. An agent would need additional context to invoke the tool 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?

Schema description coverage is low (~33%) because the description only explains three parameters (cost_per_cwu_usd, min_ask_cogs, typical_minutes) but omits top-level required fields (api_key, agent_id) and the profiles array structure. The description adds meaning for those three but insufficiently compensates for the coverage gap.

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 'Publish your cost structure for one or more task types,' with a specific verb and resource. It also explains the benefits (visible in market depth order book, unlocks job economics), distinguishing it from sibling tools like get_market_depth or browse_jobs_with_economics.

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 (when you want to publish cost structure) and provides context about the effect, but does not explicitly compare to alternatives or state when not to use. The sibling set lacks similar publish tools, so it's fairly 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 responsibility. It discloses a 1% platform fee and the api_key requirement, which are valuable. However, it lacks crucial behavioral context such as whether the transaction is reversible, the chain interaction, execution time, or potential failures. For a financial tool, these omissions are significant.

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 exceptionally concise: two sentences that convey purpose, fee, and a prerequisite. Every word earns its place with no redundancy or filler.

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 6 parameters, no output schema, and no annotations, the description covers purpose, a key behavioral trait (fee), and a prerequisite. However, it omits return values, error conditions, and post-transfer state, which are important for an agent executing a financial operation. It is minimally adequate but not 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 100%, so every parameter already has a description. The tool description adds minimal extra meaning beyond the schema (e.g., 'between agents or external wallet'). It does not clarify constraints like mutual exclusivity of 'to_agent_id' and 'recipient_address'. Baseline 3 is appropriate as the schema does the heavy lifting.

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 action ('Transfer'), the resource ('ERC-20 tokens'), and the scope ('between agents or to an external wallet'). This distinguishes it from sibling tools like 'transfer_cc' which likely handles credit card transfers. The verb-resource combination is specific and 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?

The description implies when to use (transferring ERC-20 tokens) and mentions a prerequisite ('Requires api_key'), but does not explicitly state when NOT to use or compare with alternative sibling tools such as 'transfer_cc' or 'accept_swap'. The agent must infer usage context without exclusions or guidance on 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, description discloses instant settlement and no blockchain transaction. However, it does not mention side effects (e.g., balance deduction), limits, or error conditions. Adequate but not comprehensive.

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 purpose and use cases. Every sentence adds value with no 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 no output schema, description does not explain return values or success/failure behavior. For a financial tool, slightly incomplete, but the core functionality is covered.

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 100%, so description does not need to add parameter details. It adds no additional semantics beyond the schema descriptions (e.g., amount in COGS). Baseline score of 3.

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 tool sends Capability Credits to another agent, with specific use cases (direct payments, tips, splitting earnings). This distinguishes it from siblings like 'transfer' or 'borrow_cc'.

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 when to use (payments, tips, splits) and mentions instant settlement and api_key requirement. Lacks explicit when-not-to-use or alternatives, but the 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 exist, so description bears full burden. It discloses the dual behavior and auth requirement but does not mention side effects (e.g., if updates are immediate, if previous settings are overwritten), rate limits, or output format.

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 sentences, front-loaded with purpose, no unnecessary words. Very efficient communication.

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?

Missing output schema, and description does not explain return values. Also does not clarify the relationship between flat parameters and the nested settings object, nor mention aliases (e.g., max_daily_spend and daily_spend_limit). Incomplete for full 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 covers all parameters, but description adds context by clarifying conditional requirement for api_key based on action. This goes beyond schema descriptions, aiding correct invocation.

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 'Update or retrieve an agent's settings', clearly specifying two actions. It adds nuance beyond name which suggests only update. Not a tautology, but could be more specific about the scope of settings.

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 when to use 'get' vs 'update' and that api_key is required for updates. Provides basic usage context but does not compare to sibling tools or state when not to use 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?

With no annotations, the description carries the full burden. It discloses that the tool debits internal balance and executes an ERC-20 transfer on Polygon mainnet, sets a minimum amount, and returns a transaction hash and link. However, it does not mention potential fees, reversibility, or risks, which are important for a financial transaction tool.

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, using two sentences. The first sentence states the primary action, and the second provides essential details (debit, blockchain transfer, minimum, output). No unnecessary words or 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 complexity as a financial withdrawal and the absence of output schema and annotations, the description covers key aspects: action, blockchain execution, minimum amount, and return values. However, it lacks information about transaction fees, confirmation time, failure modes, and irreversibility, leaving gaps for an AI agent to safely use the 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 100%, so baseline is 3. The description adds context like the minimum amount (1 CC = 10,000 cogs) and the default behavior for 'to_address', but does not significantly enhance parameter understanding beyond what the schema already provides.

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 'Withdraw' and the resource 'Capability Credits', specifying the destination as a Polygon wallet address. It distinguishes from sibling tools like 'transfer_cc' (internal transfer) and 'borrow_cc' by focusing on external withdrawal to a blockchain address.

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 withdrawing CC to an external Polygon wallet but does not explicitly state when to use or avoid this tool versus alternatives like 'transfer_cc' or 'borrow_cc'. No guidance on prerequisites, limitations, or when not to use is provided.

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