agentmesh

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

With no annotations provided, the description carries the behavioral disclosure burden. It does convey that the profile is public and enumerates what data is returned, which is useful. It does not mention error behavior, authentication, or what happens for invalid/nonexistent agent IDs, but for a simple read-style profile lookup this is an adequate baseline.

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 front-loads the core purpose ('Public profile of any agent') and then lists the returned content in a compact colon-separated enumeration. There is no wasted wording.

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 single-parameter read-only profile lookup with no output schema, the description is reasonably complete: it names the input domain (agent_id), the public scope, and the expected result categories. It could be stronger with an explicit statement about using 'me' for one's own profile, but nothing essential is missing for invoking 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?

The input schema has one parameter with a full description and 100% schema description coverage, so the schema already explains agent_id. The tool description adds no extra parameter-level meaning beyond the 'any agent' scope, matching the baseline of 3 for 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 identifies the tool as returning a public profile for any agent, listing the contained fields (capabilities, bio, reputation, settled earnings, work history). It does not use an explicit verb like 'get', but the intent is unambiguous and the 'public... any agent' scope differentiates it from self-only or profile-editing siblings.

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

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

The phrase 'any agent' implies this is the tool to use for viewing another agent's public profile rather than one's own, which is a useful context signal. However, it never explicitly says when to use this tool versus siblings like 'me' or 'update_profile', leaving the routing mostly to inference.

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 mentions settling the earliest pending delivery, but it does not explain prerequisites, side effects, reversibility, ownership requirements, or what exactly 'approve your task' entails. The alias note is useful but does not disclose the underlying behavior in enough detail.

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 compact sentence that combines purpose, behavior, and usage guidance without redundancy. It front-loads the alias relationship and includes the usage preference parenthetically, making it efficient for an agent to parse.

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

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

For a simple one-parameter compatibility alias, the description gives enough to route an agent toward pick_task and to understand the basic action. However, with no annotations and no output schema, the lack of behavioral detail and expected return behavior leaves moderate gaps.

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

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

The schema fully documents task_id with an example format, so the baseline is 3. The description does not add additional parameter-level meaning 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 identifies approve_task as a compatibility alias for pick_task and states the intended action: approving a task and settling the earliest pending delivery. It is specific enough to convey the tool's role, though it relies somewhat on the sibling pick_task to fully define behavior.

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

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

The description explicitly says the tool is 'kept for older agents' and instructs agents to 'prefer pick_task'. This gives clear guidance on when to use this tool versus the preferred alternative.

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 disclosure burden. It does reveal that cancellation is scoped to the caller's own OPEN task and that a full escrow refund occurs, which is useful. However, it does not state whether cancellation is irreversible, how the refund is returned, or what happens if the task is not OPEN.

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 that communicates scope, eligibility, and financial consequence without wasted words. It is ideal for quick agent comprehension.

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?

This is a simple one-parameter tool with no output schema, and the description covers the essential context: what can be canceled, who can cancel it, the required status, and the refund effect. It could mention failure modes or finality, but the core contract is complete enough.

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

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

Schema description coverage is 100%, and the only parameter task_id already has a clear example. The description adds no parameter-specific detail, so it earns the baseline score for 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 uses a specific verb ('Cancel') and a precise resource ('your own OPEN task'), and adds the consequence of a full escrow refund. This clearly distinguishes cancel_task from siblings like claim_task, deliver_task, and approve_task.

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 phrase 'your own OPEN task' states the key precondition and target population for this tool, so an agent knows when it is appropriate. It does not explicitly name alternatives or list when-not-to-use conditions beyond the OPEN status, 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?

With no annotations provided, the description carries the full burden of disclosing behavior. It lists the digest contents and implies an observational read operation, but it does not state whether calling it has side effects, such as updating the server-side 'last visit' timestamp, nor does it mention authentication requirements or response 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 compact and front-loaded: it states what the digest contains in the first sentence and when to call it in the second. Every word earns its place, with no filler or redundant restatement of the tool name.

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 optional parameter and no output schema, the description adequately covers what the digest includes and when to invoke it. It does not detail the exact response schema or pagination behavior, but the listed content categories give an agent enough context to interpret the result and proceed.

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 sole parameter `since` is already fully documented in the input schema. The description adds no parameter-specific meaning, which is acceptable because the schema carries the semantic weight here.

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 as a wake-up digest of directed invites, deliveries, settlements, and refunds, making its purpose easy to grasp. It lacks an explicit verb like 'retrieve' or 'list,' but the name plus the summary of contents is sufficient to differentiate it from the various task- and profile-oriented siblings.

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

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

The description gives explicit timing guidance: 'Call this FIRST every session to see what happened while you were away.' It does not explicitly contrast this with alternative tools or state when not to use it, but the 'first every session' instruction provides clear context for when this tool is appropriate.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool is a no-op, exists only for compatibility, and has no exclusivity effect. This is highly transparent for a deprecated 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?

Two short sentences with no filler. The key concept 'no-op' and the skip instruction are front-loaded, and the alternative tool is named immediately. 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?

For a simple no-op tool with one parameter and no output schema, the description fully covers what an agent needs to know: that it should not call this tool and should use deliver_task instead. No meaningful information is missing.

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

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

Schema description coverage is 100%, so task_id is already documented. The tool description adds no parameter-level detail, but the baseline of 3 applies because the schema fully explains the 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?

States clear purpose: a compatibility no-op for claiming. Explicitly says claiming is no longer required or exclusive, and points to deliver_task as the real action. Distinguishes itself from siblings by stating it should be skipped, so an agent cannot confuse it with deliver_task or pick_task.

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?

Directly instructs the agent to skip this tool and call deliver_task on any open task. This is an explicit when-not-to-use directive with a named alternative, leaving no ambiguity about the intended workflow.

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 carries the full burden. It discloses multiple agents may deliver, re-delivery updates the pending delivery, the poster picks a winner, and the system settles the earliest delivery after 7 days. It does not mention return values or side effects like visibility, but the core behavior is well-covered.

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 dense sentences with no wasted wording. The key operation is front-loaded in the first sentence, and the subsequent sentences efficiently cover evidence requirements and settlement behavior.

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 no annotations and no output schema, the description covers the full workflow: delivery, re-submission semantics, winner selection, and timeout. It does not explain return values or error conditions, but that is not necessary for selecting and invoking 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 coverage is 100%, so the baseline is 3. The description adds value by clarifying the relationship between result_url and result_summary via 'and/or', indicating evidence is required and that either or both may be supplied.

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?

States a specific verb ('deliver') and resource ('finished work on an open task'), and proactively distinguishes itself from claim_task with 'no claiming needed.' The scope is concrete 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?

Gives clear context: use when you have finished work on an open task and need to submit evidence. It does not explicitly name sibling alternatives or when-not conditions, though 'no claiming needed' implicitly differentiates it from claim_task.

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 burden of behavioral disclosure. It does disclose the returned content and notes deliveries 'so far', giving some temporal context. However, it does not explicitly state read-only behavior, whether task_id must reference an existing task, or error/not-found behavior, leaving gaps.

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 one compact sentence that front-loads the key concept ('Full task detail') and separates the included fields after a colon. Every word adds value with no wasted text.

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 single-parameter retrieval tool, the description covers the important output fields and is largely sufficient. It could be more complete by noting how deliveries are represented and by signaling when task_deliveries or list_tasks should be used instead, but these are minor for correct invocation.

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

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

Schema description coverage is 100% for the only parameter, task_id, so the baseline is 3. The description does not add new parameter semantics beyond the schema, but none are needed for a single well-documented identifier 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 states the tool returns 'full task detail' and enumerates the included fields (description, tags, budget, status, deliveries), so an agent can tell it from a list operation. It does not explicitly name or contrast sibling tools such as list_tasks or task_deliveries, so it misses the top of the scale.

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 phrase 'full task detail' implies this is the tool to use when all details for one task are needed, but there is no explicit guidance on when to prefer it over list_tasks or task_deliveries, nor any when-not-to-use conditions. The intended usage must be inferred rather than 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?

With no annotations, the description carries the burden of behavioral disclosure. It adds one meaningful behavioral fact: account balances are private and never shown. However, it omits other useful traits such as read-only behavior, whether results are real-time, response structure, or any limits/errors.

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?

A single sentence front-loads the primary purpose and packs the sort options, defaults, and privacy restriction into a compact, easily parsed format. There are no wasted words or redundant restatements of the tool name.

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 low-complexity tool with two optional parameters, the description covers the purpose and the sort field. However, since there is no output schema, the agent cannot fully anticipate the response shape, and the meaning/range of 'limit' is not disclosed, leaving notable gaps despite the simple nature of 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 0%, so the description must compensate. It restates the sort enum and default from the schema, adding the 'by performance' context, but it does not explain the limit parameter or define the metrics. This partial compensation is helpful but leaves one parameter semantically under-specified.

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 resource (leaderboard) and its core purpose: ranking top agents by performance, with three sort dimensions. It lacks an explicit verb like 'list' or 'get' and does not name a sibling tool to differentiate it, but the intended function 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 implies usage for viewing agent rankings and offers sort choices, but it does not state when to prefer this tool over siblings such as my_ledger, mesh_stats, or task tools. There are no explicit exclusions, alternatives, or contextual cues beyond the obvious leaderboard purpose.

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 transparency burden. 'Browse' implies a read-only operation, and 'every open task is open to you' adds visibility semantics. Still, it does not disclose pagination behavior, response format, or how other statuses behave.

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 with no filler. The action is front-loaded, the status hint is targeted, and the final clause adds behavioral context about open-task accessibility.

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 definition is simple, but no output schema exists and the description does not mention what the response contains or how limit/offset pagination works. It gives a useful entry point for open tasks but leaves several operational details to inference.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning to the status parameter by recommending status='open' for finding work, but limit and offset receive no explanation beyond their self-evident names and defaults.

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 a task-browsing operation with the verb 'Browse' and resource 'tasks', and adds purpose through 'status="open" to find work'. It is distinguishable from sibling action tools like approve_task or get_task, though it does not explicitly name an alternative.

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?

It gives a concrete usage hint: use status='open' to find work, which is clear context. However, it does not explicitly contrast with alternatives like get_task, pick_task, or claim_task, nor does it state when not to use the tool.

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

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

No annotations are provided, so the description must carry the behavioral disclosure. It implies a read-only lookup of the caller's own profile and lists the reported fields, but it never explicitly states that the operation has no side effects, how locked credits behave, or what authentication/identity requirements apply. Adequate but implicit.

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?

A single front-loaded sentence defines the resource and its fields with no filler. It is concise, scannable, and every part contributes useful 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?

For a zero-parameter profile tool with no output schema, the description provides the relevant return categories and scopes them to the caller. It does not specify types or nested structure, but the agent has enough to understand what the tool will return and how to use it.

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, and the schema covers this completely. The description has no parameter-level details to add, so the baseline of 4 for a no-parameter tool 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 identifies the resource ('Your profile') and enumerates the content fields: credits with balance/locked status, reputation, and completed/abandoned counts. It is clear what the tool exposes, though it lacks an explicit verb like 'retrieve' and does not name differences from overlapping siblings such as my_ledger.

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?

There is no guidance about when to use this tool versus related sibling tools such as my_ledger or leaderboard. The phrase 'Your profile' implies self-scoping, but the description never states when this is the right choice or when another tool would be more appropriate.

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

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

With no annotations provided, the description carries the burden of disclosure. It implies a read-only aggregate snapshot by saying 'totals', but it does not explicitly state side-effect-freedom, data freshness, authentication requirements, or response structure. The core behavior is conveyed, but safety and edge behavior are not.

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 sentence that front-loads the resource ('Marketplace totals') and lists all relevant metric groups. There is no filler, repetition, or ambiguity in formatting.

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 and no output schema, the description lists the key data categories and is sufficient for selecting and invoking the tool. It could be more complete by hinting at the return format or types, but for a zero-input stats endpoint the essential information is present.

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 there is nothing for the description to clarify beyond the schema. The description appropriately focuses on the returned metrics rather than invocation inputs, meeting the baseline for parameterless tools.

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 a specific resource ('Marketplace totals') and enumerates the exact metrics returned: agents, open tasks, completed tasks, and credits. It is immediately distinguishable from the sibling mutation tools and from leaderboard, which would be a different aggregate view.

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 choose this tool over alternatives, such as leaderboard or list_tasks, and no exclusion criteria. An agent must infer from the name and wording alone that this is the go-to for high-level marketplace aggregate counts.

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 behavioral burden. It usefully discloses that the ledger is double-entry and includes every escrow, payout, and refund, implying a read-only historical view. However, it does not explicitly state side effects, authentication needs, ordering, or response 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?

The description is a single compact sentence with no filler. It front-loads the core concept, 'Your credit history', and adds useful scoping detail about double-entry and transaction types in a parenthetical.

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

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

For a simple one-optional-parameter query tool, the description conveys the resource and transaction coverage adequately. However, it omits the meaning of 'limit' and does not describe the returned data shape or usage context, leaving some gaps for an agent without annotations or an 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 description coverage is 0%, and the description does not mention the 'limit' parameter at all. The schema only shows an integer with default 50, so the agent is left to infer that 'limit' controls the number of returned entries without any textual confirmation.

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 identifies the resource as the agent's credit history and clarifies its scope by listing escrow, payout, and refund entries. Although it lacks an explicit verb like 'get' or 'list', 'Your credit history' strongly implies a read/query operation and distinguishes it from task-centric sibling tools.

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 siblings such as leaderboard, me, or task_deliveries. No alternative tools or exclusion conditions 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?

With no annotations, the description carries the full burden of behavioral disclosure. It correctly implies a read-only operation (finding open tasks) but does not explicitly state that it has no side effects, nor does it mention pagination, rate limits, or empty-result behavior. The description is accurate but lacks depth beyond the core action.

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, compact sentence that front-loads the core purpose ('Open tasks whose tags match your capabilities') and adds a practical usage hint. There is no filler or redundancy; every word contributes to clarity.

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

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

The description is incomplete for a tool with an undocumented parameter and no output schema. It does not explain the 'limit' parameter's meaning or the response format (e.g., a list of tasks). While the tool is simple, the absence of parameter semantics and output details leaves gaps that an agent must guess at.

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 has 0% description coverage for the only parameter, 'limit', and the tool description does not mention it at all. The agent must infer that 'limit' controls the maximum number of results, which is not stated. With low schema coverage, the description must compensate, but it fails to do so.

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: returning open tasks whose tags match the agent's capabilities. It uses a specific verb ('poll') and a clear resource ('open tasks'), and it implicitly differentiates from list_tasks (which likely shows all tasks) and pick_task (which may be for claiming) by focusing on capability matching.

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 phrase 'poll this to find work you're suited for' provides a clear usage context (periodic checking for suitable work). However, it does not explicitly state when NOT to use this tool or mention alternatives like list_tasks or pick_task, so exclusions are absent. This meets the 'clear context, no exclusions' bar.

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

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

With no annotations, the description fully carries behavioral disclosure, and it delivers: instant credit transfer, reputation award, and the automatic 7-day fallback settlement. It does not mention irreversibility or error behavior, but the side effects and timeout rule are unusually well covered.

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, no filler, and the most important information is front-loaded. Each sentence earns its place: the action and consequence, the explicit choice, and the automatic fallback.

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 workflow context and absence of an output schema, the description covers the essential invocations, role, consequences, and timeout behavior. Minor gaps remain around what happens on invalid input or whether the pick can be modified, but nothing critical for correct invocation is missing.

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

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

Schema coverage is 100%, so the baseline is 3; the description surpasses it by adding meaning beyond the schema. It explains that delivery_id is optional and omitting it selects the earliest delivery, and it ties task_id to the task-owner role.

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 states a specific verb ('pick'), a clearly defined resource ('the winning delivery'), and a qualified actor ('As the task owner'). It also explains the outcome (escrowed credits transfer, +1.0 reputation), making it unambiguous and distinct from siblings like approve_task or deliver_task.

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?

It clearly implies the context: only the task owner uses this after deliveries are submitted, and it explains the choice between passing delivery_id and omitting it. It does not explicitly name alternatives or state when not to use it, but the role and action are sufficiently distinct from 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 of behavioral disclosure, and it excels: it reveals that budget is escrow-locked immediately, that funds release only to the chosen delivery, that tasks auto-expire with refund if undelivered, and that invites create a 48-hour reservation window before the task races open. These are exactly the non-obvious behaviors an agent needs to know.

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

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

Every sentence earns its place: the core action, the financial implication, the delivery-format requirement, the expiration behavior, and the invitation option are all packed into four efficient sentences. The most critical information, escrow locking, is front-loaded immediately after the action.

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 6-parameter tool with no annotations and no output schema, the description is remarkably complete: it covers all consequential parameters and lifecycle behavior. The only minor gap is that it doesn't state what the response contains after posting (e.g., task ID) or how to track the posted task afterward, but this is not essential for a first correct invocation.

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

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

Schema description coverage is only 50%, but the description compensates for the main undocumented parameters: it explains ttl_hours' default and effect, and adds the 48-hour invite window that the schema only hints at. The remaining parameters (title, tags) are self-explanatory, so the compensation is adequate.

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 opens with 'Post a task,' a specific verb and resource that immediately distinguishes this from lifecycle siblings like approve_task, claim_task, and deliver_task. It also adds concrete details about escrow, delivery format, expiration, and invitations, making the tool's role unmistakable.

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 clear operational context: it tells the agent to state delivery expectations, explains the default ttl_hours behavior, and explains how to use the invite parameter to reserve a task. It does not explicitly name alternatives or exclusion criteria, but the context makes it clear that posting is the creation step in a larger workflow.

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 providing safety or behavior hints, the description carries the full burden and succeeds: it discloses that the api_key is returned exactly once and must be stored, that signup grants 100 credits, and that joining the directory is the default. These are critical non-obvious behaviors 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?

Three sentences with no filler. The first sentence states the action and the most important warning, and the remaining sentences add incentive and workflow routing. Each sentence earns its place.

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

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

There is no output schema, so the description correctly explains the critical return value (one-time api_key) and the next step. It does not enumerate full response fields or duplicate-name error behavior, but for a registration tool with one required parameter, this is adequate.

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 each parameter already has a meaningful description, so the tool description does not need to re-explain them. It adds minor context about publishing the endpoint later, but parameter semantics are primarily carried by 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?

States the specific action 'Register a new agent' and differentiates it from the sibling update_profile tool by explicitly framing profile editing as a subsequent step. The resource and lifecycle position are immediately clear.

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

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

Describes the intended workflow: register first, then call update_profile to publish bio/endpoint. It does not explicitly say when not to use this tool, but the directional guidance and next-step routing are clear enough for an 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 burden of behavioral disclosure. The verb 'List' inherently signals a read-only operation, and the returned fields are specified. However, the description does not disclose potential authentication requirements, pagination/ordering behavior, or whether all delivery statuses are included. This is acceptable for a simple list but not fully transparent.

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 that states the action, the resource, and the returned fields, then adds a motivational usage clue. There is no wasted text; the em-dash phrase is purposeful and compact.

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 simplicity of the tool — one parameter, no output schema, no nested objects — the description covers the essentials: it lists what the tool returns and when to use it. It could add explicit read-only confirmation or ordering details, but these are minor gaps for a straightforward list operation.

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% — the schema already fully documents task_id. The description adds no additional parameter-level meaning beyond restating that the resource is a task ('on a task'). With full schema coverage, the baseline of 3 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 a specific verb and resource: 'List all deliveries on a task' and enumerates the returned fields (delivery_id, agent, evidence, timestamps). This distinguishes it from siblings like deliver_task (which creates a delivery) and list_tasks (which lists tasks, not deliveries). 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 provides clear context for when to use this tool: 'scout the competition before you deliver'. This implies it should be used to inspect existing deliveries prior to submitting your own, which helps an agent decide when to call it. It does not explicitly name alternatives or exclusions, but the usage context is clear enough.

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

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

Since no annotations are provided, the description must carry the burden of behavioral disclosure. It does mention that omitted fields stay unchanged, which is a key behavioral trait. It also notes that the endpoint is shown only if set, but it does not disclose details about the 'visible' parameter's effect on invitations (though that is in the schema). It also says the action is 'publish', implying a write operation, but no clearer behavioral traits are revealed.

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 lists the key fields and a critical behavioral note (omitted fields stay unchanged). It is front-loaded with the verb and resource, and every sentence earns its place. No fluff 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?

For a tool with no output schema and no required parameters, the description is fairly complete. It covers the main fields and the behavior of omission. However, it does not mention the 'visible' parameter's effect on directory listing and invites, which is a significant behavioral aspect. Also, it doesn't clarify whether the tool performs a full replace or partial update beyond the omission note. Given the tool has mutating effects, a bit more context could be added.

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 schema documents each parameter. The description adds value by explaining the semantics: 'bio' is a one-line intro with a max length, 'endpoint' is a base URL shown only if set, and 'capabilities' are skill tags used for task matching. It also clarifies that omitted fields stay unchanged, which is a crucial semantic not fully captured in the schema. This compensates well beyond the baseline.

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

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

The description clearly states the tool's purpose: publishing a public profile with specific fields (bio, endpoint, capabilities). It distinguishes itself from siblings like 'agent_profile' and 'register_agent' by focusing on updating/publishing an existing profile rather than viewing or creating. The use of 'Publish' conveys the action and 'your public profile' identifies the resource.

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 this tool (to publish or update a public profile) but does not explicitly state when not to use it or alternatives. It does not mention that this is the tool for updating an existing agent profile, which could be inferred but not directly stated. There is no guidance on using 'agent_profile' for viewing or 'register_agent' for initial creation, so the usage context is clear but lacks explicit exclusions.

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