AgentLot Marketplace

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

Annotations only indicate this is not read-only and not destructive. The description adds critical behavioral context: it optionally rates the seller and releases payout according to the order settlement rail, which is a significant financial consequence beyond what annotations convey.

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 entire description is one concise, front-loaded sentence with no filler. Every phrase contributes meaning: buyer role, accept action, optional rating, and payout release.

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 core behavior and essential triggering context are clear, and order_id is inferable as the required identifier. However, with no output schema, sparse parameter documentation, and no mention of reversibility or errors, the description is not fully complete for a financial settlement action.

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 33%, and the description does not compensate. It only hints that rating is optional, but does not explain order_id semantics or clarify the rating scale beyond the schema's raw minimum/maximum.

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 action: the buyer accepts delivered work, optionally rates the seller, and releases payout. This is specific enough to distinguish accept_delivery from related siblings like request_revision, open_dispute, and submit_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 states the triggering context: a buyer accepting delivered work and releasing payout. This gives an agent clear situational guidance, though it does not explicitly name when-not-to-use or alternative 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?

Annotations only state that the tool is not read-only and not destructive. The description adds valuable behavioral context by flagging this as a 'financial write action' that 'can require payment approval,' helping the agent understand side effects and potential friction beyond what the annotations provide.

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 with no wasted words. It front-loads the core action and result, then adds the critical financial caveat, making it efficient and easy to scan.

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 purpose and a key financial warning, but it leaves out operational context such as prerequisites for an accepted proposal, what happens when payment approval is required or fails, and any guidance for the undocumented request_id/proposal_id parameters. With no output schema, a bit more operational detail would be valuable.

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 50% parameter description coverage: request_id and proposal_id are undocumented. The tool description does not clarify these required IDs or the nested input object, so it fails to compensate for the schema gaps. Names are fairly self-explanatory, but the description itself adds no parameter-level meaning.

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 ('accepts'), the resource ('a proposal'), and the concrete outcome ('creates the normal AgentLot order/checkout for the proposed listing'). It is distinct from sibling tools like propose_for_request or create_order, making the tool's purpose immediately understandable.

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 clearly implies when to use the tool: after a proposal exists and a requester wants to turn it into an order. It does not explicitly name alternatives or state when not to use it, but the proposal-to-order flow is clear enough for an agent to select this over related 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?

The description adds meaningful behavioral context beyond annotations: royalties remain attached to the original owner, which clarifies a key consequence of adoption. However, it does not disclose other side effects or what changes for the adopting agent, and the annotations only indicate it is not read-only and not destructive.

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 well-structured sentence with no filler. It front-loads the action and includes the most important condition and consequence, earning every word.

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 provides the adoption-licence constraint and royalty behavior, but it lacks parameter explanation and does not describe what adoption does to the asset's ownership or status. With no output schema and minimal annotation detail, this is not enough for an agent to invoke the tool with full confidence.

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 for undocumented parameters. It implies 'asset' refers to the asset_id but does not explain asset_id or host_agent_id at all, leaving the optional host_agent_id especially ambiguous.

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 'Adopt an asset' and references licensed dormant code through the title and adoption-licence condition. It does not explicitly name a sibling alternative, but the 'adoption licence' framing distinguishes it from code submission and listing 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 gives an explicit condition for use: adopt an asset only when the original owner granted an adoption licence. This provides a clear when-to-use and a when-not-to-use boundary, though it does not name alternative sibling tools for cases where the condition is not met.

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?

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds that it returns MCP/REST/A2A entry points and zero-spend safety constraints, which clarifies the read-only nature of the returned data. It does not disclose additional behavioral traits such as authentication requirements or rate limits, but the parameterless introspection context makes those less critical.

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 13-word sentence front-loads the verb and the two concrete content categories. There is no filler, redundancy, or repetition of the title.

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?

Without an output schema, the description must tell the agent what it will get back. It names the two content categories, which is adequate for a zero-parameter introspection tool, though 'entry points' is somewhat vague (protocol names vs. actual endpoints).

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 schema description coverage is 100% vacuously, so the description carries no parameter burden. The baseline of 4 for parameterless tools 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 uses the specific verb 'Return' and names the exact resource: supported MCP/REST/A2A entry points and zero-spend safety constraints. This clearly distinguishes it from sibling capability tools like find_capability, register_capability, and sync_official_mcp_registry, which focus on searching, registering, or syncing capabilities rather than listing connection entry points.

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 given about when to prefer this tool over siblings such as get_external_integrations or find_capability. The description states what it returns but not the conditions or context for using it, leaving the agent to infer the appropriate scenario.

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?

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description's 'Read-only discovery' aligns with them. It adds a little extra context by specifying 'real AgentLot earning opportunities' and 'installed backend,' but it does not describe what the response contains, whether results are sorted, or any other behavioral characteristics beyond the annotation 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?

The description is a single concise sentence with no wasted words and front-loads the 'Read-only' qualifier. However, it is so thin that it leans toward under-specification rather than satisfying conciseness, since significant information is missing.

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 four undocumented parameters and no output schema, the description is too sparse. It does not explain input semantics, expected output, or how this tool fits among the many earning/discovery siblings, leaving the agent without enough information to invoke 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 description coverage is 0%, and the description provides no explanation of the four parameters: goal, limit, client, and capabilities. With no parameter documentation in either the schema or the description, an agent cannot understand how to construct a correct call, making this a critical 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 states a specific action ('Read-only discovery') and resource ('real AgentLot earning opportunities'), and adds context with 'through the installed backend.' It is clear about what the tool does, but it does not differentiate it from the many similar sibling tools like discover_earnings, get_opportunities, or search_global_earn.

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 no guidance on when to use this tool versus alternatives. There are numerous closely related sibling tools such as discover_earnings, rank_profitable_opportunities, and search_global_earn, but the description does not explain what makes this tool the right choice or what conditions would favor another 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?

The annotations already declare readOnlyHint=true and destructiveHint=false, and the description's 'Read' is consistent with that. It adds modest context that both a chat gateway and an earning backend are being assessed, but it does not explain behavior such as failure states, latency, or what 'readiness' actually means.

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 short sentence that leads with the verb and contains no filler. It is structurally concise and easy to parse, even though some terms like 'universal chat gateway' are semantically vague.

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 parameterless, read-only status tool, the description communicates the core purpose sufficiently. However, there is no output schema and no description of what the returned readiness status looks like, leaving some ambiguity about how to interpret the result.

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 schema description coverage is 100%, so the parameter surface is fully defined by the schema. With nothing for the description to add about parameters, the baseline of 4 is appropriate; the 'readiness' wording hints at output rather than 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 uses a specific verb ('Read') and names a concrete resource ('universal chat gateway and underlying earning backend readiness'), so an agent can tell this is a status/readiness check. However, it does not explicitly differentiate it from sibling status tools such as compute_status or agentlot_capabilities.

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

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

There is no guidance about when to use this tool versus alternatives, no mention of exclusions, and no context about situations where a sibling tool would be more appropriate. The description simply states the action without any usage direction.

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 meaningful behavioral context beyond the sparse annotations: it clarifies that AgentLot 'never reports candidate value as settled revenue' and that 'Payout/withdrawal is not performed by this tool.' This helps set expectations about outcomes. It does not, however, detail side effects of starting the workflow, such as whether it may claim or submit work on the agent's behalf.

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 three sentences with no filler. The primary action is front-loaded, followed by the behavioral caveats and the explicit payout limitation. Every 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?

The description is reasonably complete for a 7-parameter, fully optional tool. It explains what the workflow does, what it does not report, and what it does not handle (payouts). The lack of an output schema is partially mitigated by the clear behavioral framing. It would be stronger if it mentioned dry_run behavior or typical return values, but those are partially covered by the schema's dry_run description.

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 description does not explain any parameters. With schema description coverage at 71%, the schema documents most parameters, but max_jobs and capabilities appear to lack descriptions. The description makes no attempt to fill those gaps or otherwise clarify parameter semantics, so it adds no value beyond the structured 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 a specific verb and resource: 'Start AgentLot's zero-spend earning workflow for this AI.' It also defines the workflow's scope by saying it discovers, ranks, and delegates opportunities. However, it does not explicitly distinguish itself from many similar sibling tools such as earn_now, make_money_for_me, or agentlot_earn_preview.

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: when starting a zero-spend earning workflow. It also provides an exclusion: payout/withdrawal is not performed. But it does not explicitly state when to prefer this tool over alternatives or mention any conditions that would make another sibling 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?

Annotations declare readOnlyHint=true and destructiveHint=false, so this is already known to be a safe read. The description adds meaningful context about the kinds of determinations the tool makes (capabilities, blockers, cost confidence), but it does not describe output details or edge cases such as unfunded opportunities.

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 focused sentence with no filler, and the core action is front-loaded. Some jargon such as 'real cost confidence' is imprecise, but it remains compact and readable.

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 a single required parameter and read-only annotations, the description covers the input adequately and hints at what the output topics will be. However, no output schema exists, and the description never states the return format or how eligibility results are represented, so an agent must infer the response shape.

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 only parameter, opportunity_id, is self-explanatory by name. The description adds a little semantic context by specifying this is about a 'funded opportunity', but it does not explain where to get the ID or what formats are accepted. With 0% schema coverage, this is adequate but not thorough.

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 ('Assess') and target ('funded opportunity'), and lists four concrete assessment dimensions: executable status, required capabilities, blockers, and cost confidence. It is clearer than a generic 'asses eligibility', but it does not explicitly distinguish itself from the sibling assess_real_eligibility.

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 given about when to use this tool instead of alternatives such as assess_real_eligibility or estimate_profitability. The phrase 'Assess whether...' implies a use case, but it never states conditions, exclusions, or what makes this tool the right choice.

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?

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds that the tool is 'negation-aware' and 'supplier-backed', giving some insight into its logic. However, it does not explain what negation-awareness means in practice, what data sources are used, or what the response looks like. No contradiction with the annotations.

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 efficient sentence with no filler and the core verb 'assess' front-loaded. It packs several concepts into nine words, though the dense jargon makes it slightly cryptic and reduces 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?

For a tool with one parameter and no output schema, the description should at least clarify how this differs from assess_opportunity_eligibility, what kind of result is returned, and what 'negation-aware' means. None of that is present. While the read-only annotation covers safety, an agent cannot confidently decide when to call this tool or interpret the result.

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 one required opportunity_id with no description (0% coverage), so the description must compensate. It does tie the parameter to 'a funded opportunity', which is meaningful context not present in the schema. Yet it leaves out format, source, or how the ID is resolved, so compensation is only partial.

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 composite assessment – eligibility plus supplier-backed price/cost – for a funded opportunity. It is clear enough to convey the core function and vaguely distinguishes itself from the sibling assess_opportunity_eligibility, but the terms 'negation-aware' and 'supplier-backed' are unexplained jargon that leave the exact meaning fuzzy.

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 explicit guidance on when to use this tool versus assess_opportunity_eligibility or other assessment sibling tools. The only inference is from the word 'real' and 'funded opportunity', which is not a stated rule or condition. The agent is left to guess.

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 annotations already mark the tool as destructive, and the description adds meaningful side-effect context: if the bounty is funded through Stripe and still unaccepted, AgentLot refunds it before cancellation. This is a concrete behavioral detail the annotations do not convey.

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 with no filler: the first states the core action, and the second adds the conditional refund side effect. It is front-loaded and concise.

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 core action and the key financial side effect are covered, and destructiveHint handles the safety implication. However, the required request_id parameter is not explained, and there is no indication of errors or return behavior, leaving minor but real 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 documents api_key but request_id has no description, and the description does not clarify that request_id identifies which open request to cancel. With only 50% schema coverage, the description needed to compensate for the undocumented required parameter but does not.

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 specific action and resource: 'Requester cancels an open request.' It also adds the conditional refund behavior, which makes the purpose more precise and distinguishes it from related tools like open_dispute or request_revision.

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 provides clear context for when to use the tool: a requester wants to cancel an open request. It does not explicitly name alternatives or exclusions, so it stops short of full routing 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description reinforces this with 'No money moves.' It adds behavioral context by naming the specific constraint axes and clarifying this is an evaluation, not a mutation. It does not explain what happens when limits are exceeded, but annotation coverage lowers the burden.

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 definition is two short sentences, front-loaded with the core purpose and no filler. Both sentences earn their place. It is slightly too sparse to fully carry the parameter semantics, but as a concise summary it is well-structured.

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 five parameters, no output schema, and no required fields, the description leaves important gaps: it does not state what the response looks like, whether this is pass/fail or a detailed breakdown, which parameters are needed for a valid request, or what 'limits' are being compared against. An agent would still need to guess at invocation details.

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, but it only lists five categories that map loosely to the parameters. It does not explain what confidence_bps measures, what values payment_rail accepts, what capabilities should contain, or how revenue_cents interacts with spend_cents.

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 names a specific verb ('Evaluate') and resource ('a proposed action') against defined limits: spend, ROI, confidence, rail, and capability. It distinguishes itself from getters like get_economic_mandate by framing this as an assessment of a forward-looking action, and the closing 'No money moves' clarifies it is a check rather than a transaction.

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 carries an implied usage: call this before committing money to an action, since it evaluates limits and explicitly says no money moves. However, it does not explicitly state when to choose this over get_economic_mandate, estimate_profitability, or other economic checks, nor give exclusion conditions.

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?

Annotations already indicate read-only and non-destructive behavior; the description adds the important behavioral nuance that this is a pre-flight gate rather than a general state read. It clarifies that the tool re-fetches state and makes a proceed/no-proceed decision, which is useful beyond the raw annotations. No contradiction with annotations.

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 short sentence that front-lodes the action and timing. There is no filler or repeated schema information; every phrase contributes meaning.

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-param read-only gate tool, the description gives the core timing and decision, but it does not explain what the result looks like, what conditions cause failure, or what 'AgentLot may process' means concretely. Since there is no output schema, these gaps leave some ambiguity, but the description is still serviceable.

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 one required string, 'opportunity_id', with zero description coverage, and the description does not mention it. The param name gives a minimal hint that an opportunity identifier is needed, but the description provides no guidance on how to obtain it or how it factors into the gate decision. This is the weakest aspect.

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 names a specific action and resource: 're-fetch current Taskmarket state' and 'verify whether AgentLot may proceed'. This goes beyond a tautology and makes the gate-check purpose clear. It does not explicitly distingusih it from sibling tools, but the pre-write, stat-e-refetch framing is distinctive.

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 says exactly when to use it: 'immediately before any write'. That is a clear workflow-level condition. It does not name alternatives or exclusions, but the timing instruction gives enough context for an agent to know this is a pre-write gate check.

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?

Annotations already indicate readOnlyHint=true and destructiveHint=false, and the description's 'Read' aligns with that. It adds the scope of the status (universal compute and preserved-code economy) but gives no detail about output shape or other behavioral traits.

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

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

The description is a single concise sentence that leads with the action verb and states the resource. There is no redundant or filler 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 zero-parameter read-only tool, the description is minimally sufficient, but it does not explain what 'AgentLot 20.1' status contains or what return values to expect. Since there is no output schema, a bit more detail would make it more complete.

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

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

The tool has zero parameters, so there is no parameter ambiguity. Schema coverage is effectively complete, and the description does not need to compensate for any parameter documentation gaps.

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 ('Read') and resource ('combined universal compute and preserved-code economy status'), which makes the tool's function recognizable. It does not explicitly distinguish itself from sibling status tools like compute_status or agentlot_earn_status, but the combined scope provides some differentiation.

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 given about when to use this tool versus alternatives. The description only describes what it reads, with no mention of conditions, exclusions, or sibling 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?

Annotations only indicate this is not read-only and not destructive, so the description must carry more behavioral weight. It reveals that the job is 'buyer-funded' and 'competitive,' but it does not explain what side effects occur, whether funds are committed or moved, what happens after creation, or any constraints. This is thin for a money-related creation 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 a single front-loaded sentence with no filler. It is concise and to the point, though the density of jargon ('buyer-funded competitive execution job') slightly reduces how much clarity the brevity achieves.

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 six parameters, zero parameter descriptions, no output schema, and a large sibling tool list, the description is far too minimal for an agent to invoke this tool correctly and safely. Key context around modes, budget semantics, finalist counts, and financial implications 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 0%, and the description does not explain any of the six parameters. The terms 'BEST/FASTEST/CONSENSUS' loosely hint at the mode parameter, but there is no explicit mapping, and required fields like title and goal are left entirely unspecified beyond their names.

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 action ('Create') and a specific resource ('buyer-funded competitive execution job'), and names the supported outcome styles (BEST/FASTEST/CONSENSUS). It is clear enough to distinguish this from many sibling tools, though it does not explicitly name any sibling 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?

There is no guidance on when to use this tool versus related tools like create_buyer_goal, create_order, or execute_goal. The description implies a use case but provides no exclusions, prerequisites, or alternative-selection cues.

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?

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description reinforces this with 'Read'. It adds useful context by specifying the exact status areas covered (providers, caps, zero-upfront). It does not mention rate limits or freshness, but for a simple no-parameter read-only tool this is a minor gap, not a contradiction.

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 concise sentence, starts with the action verb, and contains no filler. Every word adds meaning, and the key scoping term 'compute' appears immediately.

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, read-only, annotation-backed tool, the description is essentially complete: it names the resource and the dimensions of status returned. It does not describe the response format, but the absence of an output schema and the simplicity of the tool make this a minor rather than significant omission.

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 schema coverage is 100%, so the description has no parameter-semantics burden. The domain-specific terms are output-relevant, not input-relevant, and no parameter documentation is missing.

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 clear verb ('Read') with a specific resource ('AgentLot 20.1 compute economy') and enumerates the concrete status components: compute providers, hard caps, and zero-upfront status. This distinguishes it from sibling tools like code_economy_status by scoping to the compute domain.

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 clearly implies this tool is for reading the current state of the AgentLot compute economy. It does not explicitly name alternatives or exclusion conditions, but the read-only, no-parameter status nature makes the invocation context 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?

Annotations already indicate this is not read-only and not destructive, so the bar is lower. The description adds a useful behavioral boundary by stating that private keys, seed phrases, and mnemonics are rejected. However, it does not disclose side effects, persistence, permissions, or what happens after registration.

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, no wasted words, with the key scoping constraint front-loaded. Every sentence carries meaningful 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 tool with seven parameters, no output schema, and only one parameter documented in the schema, this description is too thin. An agent still does not know what provider values mean, how to format chain, what can_spend does, or what the result of registration looks like. The public-only rejection rule is helpful but insufficient 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?

Input schema coverage is only 14%, and the description compensates for only one parameter: 'address' must be a public address rather than a secret. Provider, chain, asset, label, can_spend, and api_key semantics are left mostly unexplained, so an agent lacks meaning for most required and optional fields.

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 names a specific action ('Register') and resource ('public wallet metadata'), and it further scopes the operation by rejecting private keys, seed phrases, and mnemonics. It does not explicitly distinguish itself from sibling wallet tools, and the title's 'Connect' vs description's 'Register' introduces a minor wording mismatch.

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 given about when to use this tool instead of related siblings such as get_wallet_providers or list_my_wallets. The description only imposes input restrictions; it does not explain the intended scenario, prerequisites, 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?

The annotations indicate the tool is not read-only and not destructive, which is inherently present in the description's 'open' action. The description adds no further behavioral detail such as whether suppliers are notified, whether budget is reserved, or whether the request is reversible.

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 but under-specified; it is a minimal label rather than a helpful tool description. There is no fluff, but the lack of essential semantic content makes it inappropriate size for a tool with six parameters.

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, no parameter documentation, no usage guidance, and no return or side-effect information. The description leaves nearly every invocation detail unknown, making successful tool use unlikely without additional external knowledge.

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?

With schema description coverage at 0% and six parameters, the description must compensate by explaining parameter roles, but it mentions none. An agent has no idea what 'capability', 'goal', 'mode', 'currency', 'max_bids', or 'budget_cents' mean or how to set them.

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 recognizable verb ('open') and names a clear resource ('supplier bid request'), so an agent can tell it starts some kind of bid request. However, 'open' is vague compared to the tool's name 'create_bid_request', and there is no explicit differentiation from siblings like submit_bid or propose_for_request.

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 about when to use this tool versus alternatives such as post_request, propose_for_request, or create_buyer_goal. The description is only a single action phrase with no prerequisites, exclusions, or context about the bidding 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?

Annotations only provide readOnlyHint=false and destructiveHint=false. The description adds useful behavioral context: opening the Stripe checkout is optional, and the funded state still requires verified Stripe payment. This goes beyond structured annotations, though it does not disclose all side effects or requirements.

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 with no filler. The primary action is front-loaded, and the second sentence delivers a necessary caveat about payment verification. 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?

With 6 parameters, no output schema, and no property descriptions, a two-sentence description is not complete enough. Missing are the semantics of acceptance and deliverable, required budget format, the behavior of fund_now, and any return values or failure modes. An agent would have to guess at too much.

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 explain any parameter meaning. 'fund_now' is only alluded to via 'optionally open the existing Stripe funding checkout,' while goal, budget_cents, currency, acceptance, and deliverable remain unclarified. The tool cannot be invoked correctly without more parameter context.

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

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

The description states a specific action, 'Create buyer demand,' and a conditional behavior, 'optionally open the existing Stripe funding checkout,' which clearly identifies the operation and resource. However, it does not explicitly distinguish this tool from sibling tools like publish_demand or post_request, so it is clear but lacks sibling differentiation.

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 on when to use this tool versus alternatives such as create_order, post_request, or publish_demand. The description implies use for creating a buyer goal but provides no conditions, exclusions, or alternative routing.

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?

Annotations only indicate readOnlyHint=false and destructiveHint=false. The description adds meaningful behavioral context beyond that: authentication requirements and the potential for human payment approval via Stripe Checkout. It does not contradict the annotations.

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 brief, front-loaded with the primary action, and every sentence adds value: the core operation, the auth requirement, and a payment caveat. There is 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 6-parameter tool with no output schema, the description is too thin to fully guide correct invocation. It omits meaningful context for quantity limits, idempotency usage, buyer_note semantics, and the nested input object. The Stripe approval note is useful but not 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 only 17%, and the description does not compensate for the undocumented parameters. It implicitly maps to listing_id but does not explain quantity, buyer_note, idempotency_key, or the input object. Only api_key receives schema-level documentation.

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 ('Create'), a specific resource ('an order'), and the target ('a listing'). This distinguishes it from sibling tools like create_bid_request, create_subscription_draft, and get_listing without requiring an agent to open schemas.

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 the primary use case: buying a listing. It also provides an explicit prerequisite (Bearer AgentLot API key) and important context about fiat orders requiring Stripe Checkout approval. However, it does not explicitly name alternatives 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?

Annotations already indicate a mutating but non-destructive action (readOnlyHint=false, destructiveHint=false). The description adds only 'attributable' as a behavioral trait and does not describe side effects, persistence, or response behavior. It does not contradict the annotations, so this is acceptable but not rich.

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 filler. It conveys the core action immediately and could not be meaningfully shorter.

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?

Although the tool is simple, the description omits parameter semantics and any indication of what the tool returns or how it fits into the AgentLot workflow. With no output schema and no parameter descriptions, the definition is minimally usable but leaves significant 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 input schema provides two bare string properties, 'campaign' and 'destination', with 0% description coverage. The description does not explain either parameter's format, optionality, or meaning. The word 'attributable' only weakly hints at campaign context and leaves the agent to guess what destination should contain.

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

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

The description states a specific verb and resource: it creates an 'AgentLot referral link'. It also includes the qualifier 'attributable', which distinguishes this from generic link-creation tools and from other create_* siblings such as create_order or create_subscription_draft.

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 on when to use this tool versus alternatives. It does not mention any sibling tool, workflow context, or precondition, so an agent must infer when creating a referral link 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?

Annotations already show this is not read-only and not destructive. The description adds a meaningful behavioral trait: no charges are activated. However, it does not disclose what happens after draft creation, whether the draft persists, or what activation requires afterward.

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, tight sentence that front-loads the main purpose and adds the critical no-charge qualifier. There is no filler or unnecessary 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?

With six parameters, three required, no output schema, and minimal annotations, the description provides only a narrow slice of needed context. Missing are field guidance, draft lifecycle expectations, and any note on return values or side effects.

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 needed to compensate for undocumented parameters. It does not explain what 'capability', 'goal', 'cadence', 'currency', 'supplier_id', or 'amount_cents' mean. The word 'recurring' only weakly hints at cadence and amount semantics.

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 names a specific action ('Create'), a specific resource ('recurring-work draft'), and a key constraint ('without activating charges'). This clearly distinguishes it from sibling creation tools like create_order or create_referral.

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 wording implies the tool should be used for setting up recurring work without triggering billing, but it does not explicitly state when to choose it over alternatives or when not to use it. No sibling alternative or exclusion condition is named.

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

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

Annotations only indicate the tool is neither read-only nor destructive. The description adds behavioral context by specifying a locked-down Docker sandbox and the need for an explicitly configured secure deployment hook. However, it omits permission requirements, side effects, cost, or failure behavior, which are relevant for a tool that runs user code.

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 with no fluff. The key scope ('owned/adopted asset') and both execution modes are front-loaded, and every clause contributes meaningful distinction.

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 that executes code with no output schema and minimal annotation coverage, the description is under-specified. It does not mention what a successful run returns, how to verify the outcome, prerequisites for 'owned/adopted', or guidance on choosing between sandbox and external_hook. It is minimally usable but leaves significant 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?

With 0% schema description coverage, the description must compensate. It maps mode to the two enum values (sandbox vs external_hook) and clarifies that asset_id refers to an owned/adopted asset, but it gives no meaning for timeout_seconds, its default, or constraints. Partial compensation only.

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 ('Run') and clearly identifies the resource ('an owned/adopted asset') and the two execution contexts ('locked-down Docker sandbox' or 'secure deployment hook'). This distinguishes it from read/list/submit siblings such as get_code_asset, list_code_assets, and submit_code_asset.

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 that the asset must be owned/adopted and that there are two modes, but it does not explicitly state when to prefer this tool over alternatives like project_deploy_cloudflare or submit_code_asset, nor does it provide exclusion criteria. Usage context is present but not made explicit.

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 aligns with the readOnlyHint=true annotation and reinforces a non-committal, non-destructive operation. However, it adds little beyond the annotations: it restates the no-commitment aspect but does not disclose behavior such as result ordering, pagination, or what fields are returned. The annotation already covers the safety profile, so a mid-range score is appropriate.

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 action and scope. Every word contributes meaning, with no fluff or repetition. It is well-suited 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?

With no output schema and almost no parameter documentation, the description alone is insufficient for an agent to fully understand expected return values or how filters interact. It conveys the high-level purpose but lacks the operational detail needed for confident invocation.

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

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

Schema description coverage is 0%, and the description provides no information about limit, min_vcpu, gpu_count, or min_memory_mb. The parameter names are somewhat self-explanatory, but the description does not compensate for the missing schema documentation or clarify units or filtering behavior.

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

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

The description states a specific action ('Find compute offers') and resource ('compute offers'), and the qualifier 'without creating a financial commitment' clearly distinguishes it from commitment-based siblings like reserve_compute or create_order. The title reinforces the core value proposition. This is unambiguous and actionable.

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 'without creating a financial commitment' implies the tool is for exploration before committing, but it never explicitly says when to use this tool versus quote_compute, reserve_compute, or compute_status. No alternatives are named, so the agent must infer the appropriate selection context from the wording alone.

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?

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds meaningful behavioral context beyond that: it is public, works before authorization, reflects real current opportunities, and never guarantees income. This is useful and consistent with the annotations.

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 core purpose is front-loaded, and the 'never guarantees income' caveat earns its place by preventing an agent from overpromising results to the user.

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 read-only discovery tool, the description covers the access mode, auth prerequisite, and a key caveat. However, with no output schema and no parameter documentation, the description is not fully complete on its own: it does not describe what a returned opportunity looks like or how the input parameters shape the result.

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 for undocumented parameters. It does not mention goal, limit, skills, or currency at all. While these parameter names are somewhat self-explanatory, the description adds no guidance about how they affect the discovery behavior, which is a significant gap given the low 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 states a specific verb ('discovery'), a specific resource type ('AgentLot earning opportunities'), and a clear access mode ('public read-only'). It is clear enough to be understood, but it does not name or contrast any sibling tools, so an agent must infer how it differs from similar discovery tools like search_global_earn or discover_compute.

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 'before authorization' gives useful timing context, and 'public read-only' implies no auth is needed. However, there is no explicit guidance about when not to use this tool or which sibling alternatives to prefer, so the usage context is implied 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?

Annotations already mark it readOnly and non-destructive, and the description adds a valuable behavioral nuance: planning never spends automatically, which tells the agent it can safely plan without committing funds. This goes beyond the raw readOnlyHint by clarifying the economic side-effect scope.

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, first front-loads the core function and scope, second adds the critical safety qualifier. No redundant or filler content.

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

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

For a tool with five unannotated-in-schema parameters and no output schema, the description leaves too much to inference: what route format is returned, how budget/deadline/limit are used, and how this differs from planning/execution siblings. The readOnly annotation reduces risk concerns but not the missing call-parameter guidance.

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 provides no semantics for any of the five parameters, including how budget_cents, deadline_seconds, currency, or limit affect the planned route. The word 'goal' in the description merely echoes the required parameter name without adding meaning. The description fails to compensate for the absence of schema descriptions.

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

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

The description states a specific verb and resource: it plans an AgentLot economic route for a goal across marketplace capabilities. This clearly frames do_goal as a planning tool, though it does not explicitly name a sibling to distinguish it from plan_profitable_execution or execute_goal. The final sentence reinforces that this is planning, not spending.

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 clear context cue: use for economic route planning across marketplace capabilities, and states that planning never spends automatically. It does not explicitly name alternatives or state when-not-to-use, so an agent must infer that execution-oriented siblings like execute_goal handle the actual spending step.

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?

Annotations already mark this as readOnlyHint=true and destructiveHint=false. The description adds valuable behavioral context: it explicitly limits the search to lawful work, scopes it to the principal, and discloses that the tool does not guarantee income or spend money automatically. This clarifies the non-transactional, safe nature of the operation beyond the annotations.

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 the main action front-loaded, followed by two relevant caveats. Every word earns its place; there is 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 read-only discovery tool, the core behavior is covered, including important non-guarantees. However, the description omits the return value format and does not position the tool among its many overlapping siblings such as earn_now, find_money_opportunities, and make_money_for_me, leaving tool-selection ambiguity.

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, but it does not explain any of the four parameters (goal, limit, skills, currency). While the parameter names are somewhat suggestive, ambiguous aspects such as what 'goal' represents, what 'limit' caps, or how 'currency' is used remain unaddressed.

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 ('Find') and resource ('lawful paid-work opportunities'), and scopes it to 'this principal,' which clearly conveys the tool's function. It does not explicitly differentiate it from very similar siblings like find_money_opportunities, make_money_for_me, or search_global_earn, so it misses the top score.

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

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

No guidance is given on when to use this tool versus alternatives. The caveats 'No income guarantee and no automatic spend' are behavioral warnings rather than selection criteria, and the description never mentions more appropriate siblings such as earn_now or make_money_for_me.

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 full burden falls on the description. The words 'executor status' and 'truth state' hint at inspection/read-only behavior, but the description doesn't state side effects, what is returned, or whether the tool changes anything. This is inadequate behavioral disclosure.

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 short, but this is under-specification rather than good conciseness. The leading '25.9' appears to be an artifact, and the remaining phrase doesn't form a useful tool description.

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 no annotations and no output schema, this description is insufficient. It doesn't explain the meaning of 'truth state,' the return format, side effects, or how this tool relates to other status tools. An agent has to guess almost everything.

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 zero parameters, so there are no parameter descriptions for the tool description to supplement. Per the rule for zero-parameter tools, the baseline is 4, and no parameter explanation 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?

The description is a fragment, not a sentence with a clear verb and resource. It mostly restates the tool name ('executor status') and adds an unexplained phrase ('truth state'), so an agent cannot tell what action the tool performs. It also doesn't differentiate from closely named siblings such as agentlot_earn_status or compute_status.

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 or when to choose a sibling. The large sibling list includes related tools with similar names, but the description gives no selection criteria or 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?

Annotations already mark the tool as read-only and non-destructive. The description adds valuable behavioral context by noting that results are projected and that acceptance or income are not guaranteed, and it discloses the 10% fee assumption.

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 focused sentences with no filler. The main action is front-loaded, and the caveat about non-guaranteed outcomes is concise and useful.

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 six undocumented parameters, no output schema, and no usage guidance, the description is not fully complete for an agent deciding what to pass and when to use this tool. The annotations cover safety, but the operational context is thin.

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 clarifies estimated_cost_cents as an optional user-supplied execution cost and explains the net-after-fee logic, but it does not explain goal, limit, skills, currency, or minimum_net_cents beyond their parameter names.

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 operation: ranking paid requests by fit and projected seller net after AgentLot's 10% fee and optional execution cost. This is clear and informative, though it does not explicitly differentiate itself from the many sibling discovery/ranking 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?

There is no guidance on when to use this tool versus alternatives like discover_earnings, search_global_earn, or rank_profitable_opportunities. The intended context is implied by the title but no exclusions or routing conditions are provided.

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?

Annotations already indicate readOnlyHint and non-destructiveness, so the bar is lower; the description adds valuable context by stating it 'does not promise income or spend money automatically.' This helps manage user expectations and clarifies that this is a search/listing tool rather than an execution tool. There is no contradiction with the annotations.

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 with no wasted words; the trigger condition is front-loaded and the return/limitation statement is compact. Every clause adds 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 tool with 8 undocumented parameters and no output schema, the description is too thin. It says what is returned but not what the output looks like, how parameters affect ranking, or how this differs from the many sibling earning tools. An agent would likely need to guess parameter formats and values.

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 there are 8 parameters, so the description must compensate, but it only hints at 'fit and budget' and 'spend money automatically.' It does not explain fields like goal, limit, skills, category, currency, request_type, spend_currency, or max_spend_cents, nor allowed values for enums like currency or request_type.

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 a concrete resource ('open AgentLot requests/bounties') and a specific action ('returns ... ranked by fit and budget'), and it gives explicit trigger phrases. It does not fully distinguish itself from close siblings like discover_earnings or find_funded_work, but it is far from a tautology.

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 clearly states when to use the tool with user-intent examples such as 'make me money' and 'find paid work'. However, it does not mention when not to use it or name alternatives, so the exclusionary guidance needed for a 5 is missing.

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 annotations already communicate that this is a read-only, non-destructive operation, so the description does not need to repeat safety behavior. It adds a mild behavioral trait by framing the calculation as 'expected and risk-adjusted', implying use of success_probability and costs, but it stops short of describing formula assumptions, edge cases, or output 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 one direct sentence with no filler, and the key verbs ('Calculate expected and risk-adjusted profit') appear first. It earns every word and is easy to scan.

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, yet the description does not explain what the tool returns or in what form. Given five unmodeled parameters and no usage context, an agent has inadequate information to invoke it confidently or interpret the result.

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?

With 0% schema description coverage and 5 parameters, the description needed to explain how the inputs relate, but it only refers generically to 'an opportunity'. The parameter names are self-descriptive (reward_cents, success_probability), yet the description does not map them into the profit formula or clarify that all parameters are optional despite the schema marking none as required.

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 names a specific action ('Calculate') and a clear resource/outcome ('profit for an opportunity'), and adds the useful nuance of expected vs risk-adjusted profit. It is unambiguous on its own, though it does not explicitly differentiate from close siblings such as plan_profitable_execution or rank_profitable_opportunities.

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 usage context is given: the description does not state when to choose this over sibling tools, what inputs should be present before calling, or any alternative tool names. The closest hint is the word 'opportunity', but there is no when-to-use or 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?

The description adds domain-specific behavioral context beyond the readOnlyHint and destructiveHint annotations by clarifying that the tool plans but does not automatically spend. This is useful for an agent deciding whether this tool has financial side effects, even though the annotations already cover the read-only and non-destructive 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?

The description is very concise, front-loads the core action, and every word adds value. It wastes no space, though it could have used its brevity more effectively by covering parameter semantics or alternative tool usage.

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

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

Given five parameters with zero schema coverage, no output schema, and many closely related sibling tools, this description is incomplete. It does not describe expected return values, how mode/currency/capability/budget affect routing, or when to choose this tool over an alternative.

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?

With schema description coverage at 0%, the description needed to explain the parameters but only mentions 'goal'. The tool has five parameters, including mode, currency, capability, and budget_cents, none of which are described or mapped in the description. This leaves substantial ambiguity for an agent trying to invoke the tool correctly.

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 ('Route') and identifies both the resource ('a goal') and the target ('best available suppliers'). It also distinguishes itself from execution-type tools by adding 'Planning only; no automatic spend', though it does not name an alternative sibling.

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 'Planning only; no automatic spend' provides a clear exclusion and implies this tool is for preparing a route rather than committing funds. However, it does not explicitly state when to prefer this over related siblings like execute_goal, route_economy, or procure_outcome.

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?

Annotations already declare readOnlyHint=true and destructiveHint=false, lowering the burden on the description. The description adds a valuable behavioral guarantee—'Planning never spends automatically'—which clarifies the side-effect boundary and is not captured in the schema or annotations.

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, both substantive: the first identifies the action and object, the second adds a critical safety constraint. There is no filler or redundant restating 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?

The description is sufficient for calling the tool with just the required 'goal' parameter and understanding it does not spend money. However, it does not describe return values, the meaning of optional parameters, or how budget and currency affect planning behavior, so the agent lacks the full context needed for richer calls.

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 carries the full burden of explaining parameters. It does not clarify what 'mode', 'currency', or 'budget_cents' mean, and only 'goal' is inferable from the description. This leaves the optional parameters ambiguous and risks misuse.

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 and resource: 'Decompose a goal and build a capability plan.' This clearly distinguishes it from execution-oriented tools like do_goal and start_paid_goal, though it does not explicitly name a competing sibling tool.

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 'Planning never spends automatically' provides useful context that this is a safe planning operation. However, it does not explicitly state when to prefer this over siblings such as plan_agent_team, plan_profitable_execution, or create_buyer_goal, nor does it mention any preconditions.

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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the scope of what is searched (multiple supplier categories), but it does not disclose matching semantics, result ordering, pagination, or default behavior. This is acceptable given the annotations cover 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 filler. The enumeration of supplier types is compact and informative, though it could arguably be trimmed without losing core meaning.

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 search tool with three undocumented optional parameters, no output schema, no enums, and many closely related sibling tools, this description is too thin. It does not explain how the parameters combine, what a response looks like, or how this differs from other search-capability tools, leaving significant gaps for an agent deciding whether and how to invoke 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?

Schema description coverage is 0%, so the description must compensate for undocumented parameters. The listed categories partially illuminate the 'supplier_types' parameter, but 'capability' and 'limit' receive no explanation, leaving most parameter semantics ambiguous. The description adds some value but not enough to overcome the 0% 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 states a specific verb ('Search') and a resource ('suppliers'), and enumerates the categories covered: AI, human, API, compute, data, file, software, and hybrid. It is clear on its own, but it does not differentiate itself from the very similarly named sibling tool 'search_capability_suppliers'.

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 no guidance on when to use this tool instead of related siblings such as 'search_capability_suppliers', 'discover_compute', or 'search_supply_graph'. There is no mention of preferred scenarios, exclusions, or alternatives, so an agent would have to guess which search tool fits.

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?

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds meaningful behavioral context beyond this: 'Zero upfront capital and no spending' clarifies the financial implications, and 'Does not guarantee income' sets outcome expectations. No contradiction with annotations.

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 three short sentences with no filler. The core action is front-loaded in the first sentence, followed by the key financial trait and a risk caveat. Every 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?

With four parameters and 0% schema coverage, the description leaves parameter semantics completely unexplained. It also doesn't guide the agent toward or away from any of the many sibling tools. The safety annotations cover part of the behavioral profile, but the overall definition is too sparse 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 0%, and the description provides no information about the four parameters (goal, limit, skills, currency). The description does not compensate for the completely undocumented schema, so an agent cannot determine what values or formats to supply.

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 and resource: 'Find only funded AgentLot jobs.' The 'only funded' qualifier makes the scope clear. It doesn't explicitly name a sibling alternative, but the distinction from general search tools like search_global_market or find_money_opportunities is implied.

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?

'Zero upfront capital and no spending' implies the tool is appropriate when the user wants funded work without upfront cost, and 'Does not guarantee income' sets expectations. However, it doesn't explicitly state when to use this tool versus alternatives or provide exclusions, leaving selection to inference given the large sibling list.

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?

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description reinforces this with 'read-only call' without contradicting it. It adds genuinely useful behavioral context beyond the annotations: the default zero-upfront/no-spend filtering behavior and the caution that 'Affiliate commission requires a real conversion and is never guaranteed,' which tempers expectations that listed opportunities will pay out. It does not mention result ranking, pagination, or return shape, but with annotations covering the safety profile, a 4 is fair.

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, each earning its place: the first states the core operation and scope, the second the default filter behavior, and the third a critical caveat about non-guaranteed affiliate payouts. There is no filler and no repetition of what the schema or annotations already state, and the most important 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 read-only aggregator with four optional parameters and no output schema, the description covers the what and the default behavior but leaves two parameters unexplained and never positions itself against the crowded sibling list of search/earn tools. Given that moderate complexity, a sentence or two about parameter meaning or sibling differentiation would make it 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?

With 0% schema description coverage, the description carries the burden of explaining the four parameters, and it partially delivers: 'Defaults to zero-upfront/no-spend opportunities' maps to the no_spend_only parameter's behavior, and the three resource categories loosely suggest possible types values. However, limit and skills receive no explanation at all, leaving an agent to guess their format and semantics.

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 and resource set: 'Search funded AgentLot jobs, external bounties and configured affiliate opportunities in one read-only call.' This clearly identifies what the tool searches and the categories it aggregates, and the title's 'legitimate' framing adds useful flavor. It stops short of a 5 because it never distinguishes itself from the dense field of similarly purposed siblings like get_opportunities, find_funded_work, and discover_earnings.

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 'in one read-only call' implies this is the aggregation tool for multiple opportunity categories at once, and 'Defaults to zero-upfront/no-spend opportunities' hints at its typical use case. However, no alternatives are named and no when-not-to-use conditions are given, which matters given the ~90 siblings including find_funded_work, search_external_earn, and rank_profitable_opportunities. Usage context is implied, not explicit.

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 carry the full transparency burden. It discloses useful traits: the token is short-lived, zero-spend, principal-bound, and requires verification of the current token before issuance. It does not describe failure modes, side effects, or whether the previous token is invalidated.

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 and key constraints without filler. It does not repeat schema fields or title information unnecessarily.

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 two string parameters and no output schema, the description covers the core purpose and important constraints like zero-spend and short-lived. It leaves open the response format and behavior on verification failure, but the simple signature makes this moderately complete.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning by linking 'current token' to capability_token and 'same principal/run' to run_id, but it does not specify token formats, where to obtain them, or expiration expectations. The parameter names are fairly self-explanatory, making this minimally 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 uses a specific verb ('Issue') and names the resource ('short-lived zero-spend capability token'), scoped to the same principal/run. This clearly distinguishes it from token registration or discovery siblings, though it does not explicitly name any 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?

The phrase 'after verifying the current token' implies the tool is used when an existing token needs renewal for the same run/principal. However, there is no explicit when-to-use versus when-not-to-use guidance, nor any mention of alternatives like register_capability or find_capability.

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 behavioral burden. It does disclose that capability-token and ownership checks occur before execution, which is valuable, but it does not explain what happens on failure, whether execution is sandboxed, what side effects occur, or what the response contains. This is thinner than needed for an unannotated mutation/proxy 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 a single compact, front-loaded sentence with no filler. However, it is under-specified for a generic proxy tool and provides no structure such as expected usage patterns or parameter roles, so conciseness edges toward incompleteness rather than efficiency.

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 complex generic tool with four parameters, a nested arguments object, no output schema, and no annotations. The description explains neither how to construct arguments, what 'tool' should contain, what the return value looks like, nor how failures surface. An agent would not have enough information to call this 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 0%, so the description must compensate, but it only loosely hints at capability_token and run_id through the phrases 'capability-token and ownership checks' and 'for this run.' The 'tool' and especially 'arguments' parameters are left unexplained, and the nested object structure receives no guidance at all.

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 names a specific action ('Proxy an approved project executor tool') and a resource ('for this run'), making the core purpose clear beyond the tool name. It does not explicitly differentiate from sibling project_* and gateway_* tools, so it falls short of a 5.

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 no guidance on when to use this gateway versus direct executor tools like project_read_file, project_write_file, or gateway_run_status. It implies a proxy role but provides no exclusions, alternatives, or preconditions beyond the mention of capability-token and ownership checks.

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?

There are no annotations, so the description carries the burden of behavioral disclosure. It does reveal meaningful traits: the operation is zero-spend, isolated, durable, and can either create or resume a run. However, it doesn't mention side effects, authentication needs, failure modes, or whether the executor call is blocking or asynchronous.

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 dense sentence with no filler. It front-loads the core action, then specifies the delegated work request. It is short and structurally efficient, though jargon-heavy terms like 'external-AI principal' and 'AgentLot executor' may require prior context.

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 should provide more context about what happens after invocation, what a successful run looks like, what 'durable' implies, and what the AgentLot executor returns. The provided description is conceptually useful but leaves key operational expectations undocumented for an agent to call this 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 75%: provider, idempotency_key, and external_client_id have descriptions, but display_name is completely undocumented and the description itself adds no param-specific meaning beyond the schema. The description's 'external-AI principal' and 'durable earning run' concepts loosely relate to provider and idempotency, but the gap for display_name remains.

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 clear intended action: create or resume an isolated external-AI earning run and request profitable zero-spend work. It includes a specific verb and resource, and the 'zero-spend' and 'external-AI principal' qualifiers help distinguish it from generic siblings like 'earn' or 'make_money_for_me', though it doesn't 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?

The description implies the tool should be used when bootstrapping a zero-spend earning run through an external AI principal and the AgentLot executor. It gives procedural context ('Create or resume... then ask...') but provides no explicit when-to-use versus alternatives or exclusion criteria.

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 explicitly signals read-only behavior via 'Read', discloses the append-only nature of the event hashes, and identifies the scoped capability token as an access requirement. With no annotations available, this gives an agent a meaningful baseline understanding of side effects and auth, though it omits error/expiry 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?

One sentence, front-loaded with the verb and object, with no redundant words. Every phrase ('one run', 'append-only event hashes', 'scoped capability token') carries 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 no annotations and no output schema, the description covers the key inputs and general read behavior, but leaves out return format, failure semantics, and where the capability token comes from. For a simple two-parameter read this is 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?

The schema provides no property descriptions (0% coverage), but the description maps run_id to 'one run' and capability_token to 'scoped capability token.' It does not specify formats, token acquisition, or value constraints, so it only partially compensates for the empty 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 names a specific action ('Read') and a specific resource ('one run and append-only event hashes'), making the tool's core function clear. It does not explicitly contrast it with sibling status/capability tools, so sibling differentiation is absent.

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 on when to use this tool instead of siblings like agentlot_earn_status, gateway_executor_call, or gateway_capability_refresh. The description simply states the operation and provides no exclusions, prerequisites beyond the token, or decision 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?

Annotations already declare readOnly and non-destructive behavior. The description adds useful output-shaping information (principal vs pending, per-currency grouping), but it does not disclose edge cases such as supported currencies, whether pending earnings are estimates, or which wallet/account scope is queried.

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?

One concise sentence, front-loaded with the action and result, with no filler or repetition of the title. 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 zero-parameter read-only tool with no output schema, the description conveys the essential return concepts. It is slightly thin on behavioral edge cases, but the low complexity and readOnly annotation keep it 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?

The tool has zero parameters, so the schema fully covers parameter semantics by definition. The baseline of 4 applies because there is no parameter-level information for the description to compensate for.

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 and resource: 'Return principal balances and pending earnings by currency.' This clearly distinguishes it from broader money/revenue tools, though it does not explicitly name a sibling or contrast it with get_earnings or get_money.

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 when-to-use or when-not-to-use guidance is provided. An agent choosing among get_balance, get_earnings, get_money, and get_revenue_dashboard must rely on the name and one-line description alone, with no alternatives or exclusions 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?

The readOnlyHint annotation already signals a safe read operation, and the description supplements this by specifying the status categories returned (lifecycle, deployment, adoption, settled revenue). It adds useful behavioral scope without contradicting the annotations.

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 dense sentence delivers the verb, resource, scope, and the exact status dimensions. Every word earns its place, 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 one-parameter read-only getter with no output schema, the description is complete enough: it names the input audience, the output areas, and the operation type. The annotated read-only and non-destructive hints further cover the safety context an agent needs.

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 only parameter, asset_id, has no schema description, but the tool description's phrase 'for one code asset' clarifies that asset_id identifies the code asset whose status is being read. This is sufficient for a single self-explanatory string parameter, though it does not elaborate on ID format or provenance.

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 ('Read') with a clear resource and scope ('one code asset') and enumerates the exact status dimensions covered: lifecycle, deployment, adoption, and settled revenue. This distinguishes it from plural listing tools like list_code_assets and from mutating siblings like deploy_code_asset or adopt_code_asset.

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 clearly implies when to use the tool: when you have a single code asset identifier and need its status. It does not explicitly name alternatives or exclusions, but the singular scope and read-only framing provide adequate context for an agent to select 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful scoping ('lifetime and pending marketplace earnings', 'linked agents') but does not mention return format, authentication needs, or other behavioral traits beyond the annotations.

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, well-structured sentence that conveys the tool's purpose without any wasted words. Key scoping details are 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 zero-parameter read-only tool, the description is largely complete: it explains what the tool returns and for whom. Minor ambiguity remains around what 'linked agents' means and what the exact response structure is, but no input configuration is needed to invoke 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, so schema coverage is trivially 100%. The description adds meaningful context about what data is returned, which is sufficient for a no-input read tool.

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 ('return') and resource ('lifetime and pending marketplace earnings for linked agents'). It is immediately understandable and distinct from sibling tools like get_balance or get_revenue_dashboard, though it does not explicitly name a differentiating sibling.

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 about when to use this tool versus alternatives such as discover_earnings, get_revenue_dashboard, or agentlot_earn_status. The description gives no context on selection criteria, prerequisites, or 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description's 'Read' wording is consistent with that. The words 'authenticated canonical' add minor context about the source and authorization, but no additional behavioral traits such as return format or required authentication context are disclosed.

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 clear sentence with no filler or repetition. It is appropriately sized for a zero-parameter read operation.

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-input read tool, the description is minimally sufficient: an agent can invoke it without arguments. However, the domain-specific term 'economic mandate' is never explained, and no output schema exists to clarify what the returned mandate looks like, so an agent may not fully understand what result to expect.

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 description does not need to explain parameter meanings. The baseline of 4 is appropriate because there is no parameter-related ambiguity to resolve.

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 ('Read') and names a specific resource ('authenticated canonical economic mandate'), so it clearly states what the tool does. However, it does not explicitly differentiate from the similar sibling tool check_economic_mandate, leaving some ambiguity about how 'read' differs from 'check'.

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 alternatives. The sibling list includes check_economic_mandate, which likely serves a related purpose, but the description does not explain which one an agent should choose in a given situation.

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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is established. The description adds useful context about the data returned (reputation, completed work, GMV, quality, verified evidence), but does not disclose output structure, authorization needs, or any other behavioral nuance.

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 filler or redundant restatement of the title. Every word contributes meaning, making it easy to parse quickly.

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 read-only getter with one parameter and no output schema, the description lists the main return content, which is helpful. However, it omits parameter semantics and any indication of the result format or how the passport should be interpreted, leaving moderate gaps for an agent deciding whether and how to invoke 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?

Schema description coverage is 0%, and the description does not explain the agent_id parameter at all. The parameter name and tool title make it likely an agent identifier, but no format, source, or examples are given, so the description fails to compensate for the missing schema documentation.

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 uses a specific verb ('Get') and names a specific resource ('portable AgentLot economic reputation') while enumerating its contents: completed work, GMV, quality, and verified evidence. This distinguishes it from many siblings, though it could more explicitly contrast with overlapping tools like get_earnings.

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 given on when to use this tool versus alternatives such as get_earnings or get_growth_stats. The word 'portable' hints at a use case, but there is no explicit when/when-not or alternative routing, so an agent must infer the appropriate 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description's 'Show' is consistent with a read operation. The description adds some scoping about adapters and modes but does not disclose extra behavioral traits such as data source, freshness, or formatting.

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 with no filler and leads with the action. Minor ambiguity around 'conservative routing/resale modes' prevents a perfect score.

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 zero-parameter read tool, the description is mostly adequate, and annotations cover safety. However, with no output schema, the description does not clarify the return shape or what 'external source adapters' and 'modes' mean in practical terms, leaving some ambiguity 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?

The tool has zero parameters, so the schema leaves no semantic gaps for the description to fill. The description appropriately focuses on what the tool returns rather than parameter 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 states a specific action ('Show') and resource ('external source adapters and conservative routing/resale modes'), setting it apart from sibling tools like search_external_catalog or get_market_intelligence. The phrasing is somewhat jargon-heavy, but the core purpose is identifiable.

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 alternatives such as search_external_catalog, search_external_earn, or get_market_intelligence. No context, prerequisites, or exclusions are provided.

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 readOnlyHint=true and destructiveHint=false annotations already establish that this is a safe read operation. The description adds useful scoping ('AgentLot GMV/fees' vs 'external catalog size') but does not disclose additional behavioral details such as whether the stats are computed live, cached, or what the exact response structure looks like. It does not contradict the annotations.

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 with no filler, and the main object ('AgentLot GMV/fees') appears before the exclusionary qualifier. Every word contributes meaning, and the structure is immediately parseable.

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, read-only stats endpoint, the description is functionally sufficient: an agent can tell when to call it and roughly what it returns. The lack of an output schema means return-shape details are not provided, but the low complexity and clear scope make this a minor gap rather than a critical omission.

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 schema already provides complete parameter information. The description does not need to explain parameter semantics, and the baseline of 4 applies. No parameter-related information is missing.

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 ('Return') and a concrete resource ('AgentLot GMV/fees'), and it explicitly contrasts this with 'external catalog size', which distinguishes it from sibling tools like search_external_catalog or get_market_stats. Even though the title adds 'real growth stats', the description itself clearly defines what the tool returns.

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 'separately from external catalog size' gives clear context for when this tool is appropriate: when the agent needs AgentLot-specific GMV/fees rather than external catalog metrics. It does not explicitly name alternatives or state 'use X instead', but the contrast is enough to guide selection among 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?

Annotations already declare this as read-only and non-destructive, so the safety profile is covered. The description adds useful behavioral context by specifying that only active listings are returned and what content is included, but it does not cover edge cases such as invalid or inactive listing IDs.

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, focused sentence with no filler. The core action and resource are front-loaded, and the content details follow efficiently.

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 read-only tool with one parameter and annotations covering safety, the description is largely complete: it names the resource, its active-state constraint, and the key return fields. It could mention what happens when a listing is not found or inactive, but that is a minor gap given the tool's simplicity.

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 explain the listing_id parameter format, source, or how to obtain it. The parameter name is self-explanatory, but the description adds no value beyond what the schema property name already conveys.

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 ('get'), a specific resource ('one active AgentLot listing'), and enumerates the key data returned (price, seller reputation, input/output schemas). This clearly distinguishes it from sibling tools like search_listings, which find or list multiple listings.

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 clearly implies this is the tool for retrieving a single specific active listing by ID, which gives an agent context on when to use it. It does not explicitly name alternatives or exclusion conditions, but the singular 'one active listing' provides sufficient 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?

The annotations already declare readOnlyHint=true and destructiveHint=false, and the description's 'Read' is consistent with that. The description adds a small amount of behavioral context by narrowing the scope to supply/demand intelligence, but it does not explain what the returned intelligence contains or any edge behavior. With annotations covering the safety profile, this is acceptable but minimal.

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 filler or repetition. Every word adds meaning, and for a zero-parameter read-only tool, this is an appropriately sized definition.

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 is simple: no parameters, read-only annotations, and no output schema. An agent can safely invoke it, but the description is thin on what the intelligence actually includes and how it relates to sibling market tools. It is minimally viable but leaves room 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?

There are zero parameters and the schema is empty, so the description has no parameter burden to carry. The schema already fully covers the parameter surface, earning the baseline for a zero-parameter tool.

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 clear verb ('Read') and names a specific resource ('supply/demand market intelligence'), so an agent knows the basic operation. However, it does not differentiate this from sibling tools like get_market_stats or get_market_money_metrics, so it is clear but not uniquely scoped.

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

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

No guidance is provided about when to use this tool instead of the many overlapping market-related siblings such as get_market_stats, get_market_money_metrics, or search_global_market. The phrase 'supply/demand' implies a niche, but there are no explicit usage conditions 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful semantic detail about what is returned ('completed', 'actual', 'open funded jobs') but does not disclose any behavioral caveats such as data freshness, aggregation logic, or access requirements.

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 with no filler. It states the main outputs immediately and does not repeat obvious information beyond what the title already conveys, which is acceptable.

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 parameterless, read-only metrics tool, the description gives enough information about what the agent will receive: completed GMV, actual platform fees, and open funded jobs. There is no output schema, so explaining these return components is valuable and mostly sufficient, though some format or period detail could still 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?

The tool has zero parameters, so the baseline is 4. The description provides no parameter-level detail, which is appropriate since there is nothing to configure. The focus is on the output, which the description partially conveys.

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 clear verb ('Return') and names a specific resource: completed GMV, actual platform fees, and open funded jobs. It is clear and informative, though it does not explicitly distinguish itself from siblings like get_market_stats or get_revenue_dashboard.

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 given about when to use this tool versus the many sibling tools that also deal with market, money, or earnings metrics. The description only states what it returns, not the context or conditions that should lead an agent to select 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?

Annotations already mark the tool as read-only and non-destructive. The description adds 'public' and 'live' context, which is useful, but it does not disclose return shape, pagination, or any caveats. It is consistent with annotations and adds some value, but no detailed behavioral traits.

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

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

The description is a single sentence with no wasted words. It is front-loaded with the action 'Read' and immediately specifies what is read and the public scope. Extremely economical.

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 read-only tool, the description adequately states what counts are returned. It lacks a bit of detail on the exact return structure and the meaning of 'source', but given the simplicity and existing annotations, it is sufficient for an agent to call 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?

The tool has zero parameters and the schema coverage is 100% with an empty properties object. There are no parameters to document, so the baseline of 4 applies. The description does not need to add parameter semantics.

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 clear verb 'Read' and names a concrete resource: 'public service, opportunity and source counts'. It is specific enough to convey the tool's function, but it does not differentiate it from sibling tools like get_growth_stats or get_market_intelligence, which also sound market-related.

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 on when to choose this tool over the many market-related siblings, nor any exclusions or alternatives. The agent is left to infer usage from the name and terse description.

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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds that Bearer authentication is required and that the returned identity is for the authenticated agent, which is modest context. It does not explain error behavior or how the optional api_key parameter interacts with connector-level auth, but this does not contradict the annotations.

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, with the primary action front-loaded and the key prerequisite in the second sentence. There is no filler, redundancy, or unnecessary 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?

For a simple read-only identity getter, this is nearly complete: it states what is returned and what authentication is needed. With no output schema, a little more detail about the shape of the identity object or how this differs from sibling tools would make it fully complete, but th current level is adequate for selection and 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?

The single parameter is fully documented in the input schema with 100% coverage, including when api_key is optional and when connector-level Bearer auth is preferable. The description adds no additional parameter-level meaning, so it correctly rests on 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 states a specific verb and resource: 'Return the authenticated AgentLot agent identity.' This makes the tool's purpose unmistakable. However, it does not diffentiate from potential sister tools like 'me' or 'identity_exchange', so it falls short of a 5.

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 given about when to choose get_me over alternative identity-related tools. The only non-purpose statement is the authentication prerequisite 'Requires Bearer AgentLot API key,' which is a requirement rather than usage direction. There are no exclusions or alternative tool names.

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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful context that the tool reports ledger metadata and explicitly does not claim a withdrawable cash balance, while noting the authenticated scope. It does not disclose return format or error behavior, but with annotations present the bar is lower.

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 with no filler: the first front-loads the action and result categories, and the second adds a relevant caveat. Every sentence contributes meaning, and the structure is easy to scan.

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 one-parameter read-only snapshot with annotations, the description covers what is returned (earnings/spend, pending earnings, mandate, ledger metadata) and a key limitation (no cash balance). There is no output schema, but the listed return categories set adequate expectations. It could specify response shape, but the low complexity does not demand more.

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 api_key parameter is fully documented in the schema with 100% coverage, so the description does not need to add much. It mentions 'authenticated' in the body, reinforcing the auth context, but adds no parameter-level semantics beyond what the schema already 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 uses a clear verb ('Return') and a defined resource: authenticated agent marketplace earnings/spend, pending earnings, mandate, and ledger metadata. The second sentence adds a distinguishing caveat about no withdrawable cash balance, which helps differentiate it from balance-focused tools like get_balance. However, it does not explicitly separate it from overlapping money siblings like get_earnings or discover_earnings, so it falls short of a full 5.

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 alternative routing is provided. The caveat that AgentLot does not claim an internal withdrawable cash balance implies the tool is not for retrieving an accessible balance, but it does not name a sibling or specify conditions. The usage context is mostly implied by the 'economic snapshot' framing.

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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. However, the description adds almost no behavioral context: it does not explain what 'rank' produces (e.g., sorted list, scores), how the 5.2 EARN engine behaves, or any side effects. The opaque '5.2 EARN engine' reference actually obscures behavior rather than clarifying it.

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 short sentence with no filler words, so it is technically concise and front-loaded. However, it is under-specified: the '5.2 EARN engine' phrase adds jargon without explanatory value, and the brevity leaves out essential information. Minimalism here is not appropriately sized.

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 4 undocumented parameters, no output schema, and a vague proprietary engine reference, one sentence is grossly insufficient. The agent cannot determine expected input formats, how parameters influence ranking, what the returned data looks like, or when this tool is preferable to its many siblings.

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 provides no information about the four parameters (goal, limit, skills, currency). With zero schema documentation and zero compensation in the description, the agent cannot infer parameter meaning, formats, or relationships from either source.

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 ('Rank') and resource ('opportunities') and names the mechanism (5.2 EARN engine), so it is not a tautology. However, it does not clarify what 'opportunities' are or how this ranking differs from the many sibling tools that also list, search, or rank opportunities, leaving its purpose ambiguous.

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 such as search_global_earn, list_build_opportunities, or rank_profitable_opportunities. The phrase 'using the 5.2 EARN engine' vaguely implies a particular ranking approach but does not state a condition, context, or exclusion.

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 annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the buyer/seller order scope and visibility constraint, but does not disclose behaviors such as not-found handling, authorization details, or response characteristics. No contradiction with annotations exists.

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 contains the verb, resource, and scope with zero filler. Every word earns its place, and it is appropriately sized for a simple read-by-id 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?

The tool is relatively simple and the annotations cover the read-only nature, but there is no output schema and the description does not explain the required order_id or when this tool should be chosen over sibling read/list tools. It is minimally viable but leaves noticeable gaps.

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

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

Schema coverage is only 50%: api_key has a description, but required order_id has none. The description also fails to explain what order_id represents, where it comes from, or its expected format, so it does not compensate for the undocumented required 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 identifies a specific verb (Get), a concrete resource (buyer/seller order), and an access scope (visible to authenticated agent), so the agent can recognize this as a single-order read operation. It does not explicitly differentiate from similar siblings such as get_listing or list_requests, but the resource type is specific enough to avoid major 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?

There is no guidance on when to use this tool versus alternatives like list_requests, get_listing, or create_order. The only contextual hint is 'visible to the authenticated agent,' which implies a permission boundary but does not provide exclusions or name sibling 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the basic safety profile. The description adds a meaningful behavioral guarantee: 'Never returns or accepts private keys,' which is useful context beyond the annotations and reassures agents about secret handling during invocation.

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 primary action is front-loaded, and the second sentence provides a concise, valuable safety qualifier. 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 zero-parameter, annotated read-only tool, the description is sufficient to understand what the tool does and what safety guarantees apply. No output schema exists, but 'List' adequately implies a collection return. The low complexity means the description is complete enough for an agent to invoke 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?

The tool has zero parameters, so parameter semantics are trivially satisfied. Schema description coverage is 100%, and the description's note that it never accepts private keys usefully reinforces that no secret inputs are expected. The baseline of 4 for zero-parameter tools 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 and resource ('List headless payout rails') and clearly identifies a read-only listing action. It does not, however, differentiate this tool from similarly named siblings such as get_payout_options or list_payment_methods, and 'headless' is jargon that is not explained.

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 alternatives like get_payout_options, list_payment_methods, or set_payout_method. The description does not state any preferred context, exclusions, or conditions that would help an agent choose among the closely related payout 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?

The readOnlyHint and destructiveHint already signal a safe read operation, and the description adds useful context: the results are scoped to authenticated payout options and specific provider types. It does not contradict the annotations and provides a bit extra source-level 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?

One compact sentence with no redundant wording. The most decision-relevant details—authentication and provider sources—are placed at the beginning, and every word contributes meaning.

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 read-only tool with no required parameters and a single documented optional parameter, the description is fairly adequate. But it does not clarify the shape of the returned options or how this tool relates to similarly named payout/wallet siblings, leaving a modest completeness gap.

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 optional api_key parameter is already fully described in the input schema with 100% coverage. The description adds no paramer-level detail, so the baseline 3 applies because the schema already carries the load.

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 (payout options) and their two sources (Stripe Connect and connected user-controlled crypto wallets), which helps distinguish the tool from close siblings like get_payout_methods or get_wallet_providers. However, the description itself lacks an explicit verb, relying on the title's 'Get' to convey the action.

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 no guidance on when to choose this tool versus alternatives such as get_payout_methods, list_payment_methods, or get_wallet_providers. It only implies an authentication prerequisite, but does not state when this option should be preferred or avoided.

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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds only the 'scoped principal' qualifier, which hints at scope behavior but does not explain how scope is determined, what permissions look like, or any auth requirements. It neither contradicts annotations nor adds substantial 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 a single four-word sentence that is front-loaded with the action and resource. It contains no filler or redundant restatement of the 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 zero-parameter read-only tool, the description provides the essential return concept: scoped principal permissions. However, there is no output schema or elaboration on the permission structure, and no sibling differentiation, so an agent may still be uncertain about the exact meaning and when 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?

There are zero parameters and the schema is trivially 100% covered, so the baseline is 4. The description's phrase 'scoped principal' helps explain why no explicit scope parameter is needed: the scope is the calling principal.

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 ('Return') and resource ('scoped principal permissions'), and the title adds 'economic' domain context. It is clear enough to be told apart from most siblings, though it does not explicitly distinguish itself from overlapping tools like get_economic_mandate or get_economic_passport.

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 on when to call this tool versus alternatives. With dozens of get_* siblings, an agent is left to infer eligibility and selection criteria from the name alone.

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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description is not burdened with basic safety disclosure. It adds useful scoping context ('for the authenticated identity') and names the specific metric categories, but does not disclose return format, pagination, or authentication edge cases beyond what the schema implies.

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 is front-loaded with the action and immediately lists the concrete metrics. There is 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?

For a simple read-only tool with one optional parameter, the description covers what is retrieved and for whom. It lacks an explicit return-value outline and sibling differentiation, but the low complexity and complete schema keep this from being a significant gap.

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 description covers 100% of parameters, including the optional api_key and guidance to prefer connector-level Bearer auth. The description adds no parameter-specific meaning, but since schema coverage is complete, the 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 states a clear action ('Read') and identifies the resource: revenue metrics including funded demand, paid GMV, and AgentLot fee metrics. It is specific enough to distinguish from generic getters like get_balance or get_earnings, though it does not explicitly name sibling tools for differentiation.

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 given about when to use this tool instead of related revenue/metrics tools like get_growth_stats or get_market_money_metrics. The phrase 'for the authenticated identity' implies a scope limitation, but there is no explicit when-to-use or 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?

Annotations already provide readOnlyHint=true and destructiveHint=false, lowering the bar for behavioral disclosure. The description adds genuine value beyond this with the security guarantee "AgentLot never asks for a seed phrase/private key," which meaningfully shapes agent behavior by ruling out a harmful interaction pattern. The description is consistent with the read-only annotation and adds a distinctive trust boundary not captured by the structured fields.

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 zero waste. The primary purpose is front-loaded in the first sentence, and the second sentence delivers a high-value security guarantee. Every word earns its place for a tool this simple.

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 zero required parameters, full schema coverage, and read-only annotations, the description is nearly complete: it states the outcome, the security boundary, and the schema documents the only optional parameter. The main missing piece is positioning against the dense cluster of wallet/payment siblings, and since there is no output schema, a slightly richer hint about the returned shape would improve completeness, but the low complexity keeps this from being a major deficiency.

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 of 3 applies. The single api_key parameter is well-documented in the schema (optional, when to use it, preferred alternative), and the description doesn't need to repeat this. The description adds no parameter-level detail itself, but none is required given the schema's completeness.

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 and resource: "Return user-controlled wallet options for AI agents." The qualifier "user-controlled" adds meaningful scope beyond just 'wallet options,' and the second sentence reinforces what the tool is not (a credential-harvesting flow). However, it does not differentiate from closely related siblings in the same space (list_my_wallets, get_payout_options, get_payout_methods, connect_public_wallet), so an agent cannot tell them apart from the description alone.

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 on when to use this tool versus alternatives. With several overlapping wallet/payment siblings listed (list_my_wallets, get_payout_options, get_payout_methods), the absence of any selection criteria or exclusionary statement is a significant gap. The only usage-related hint ('Prefer connector-level Bearer auth for persistent integrations') is authentication guidance for the optional api_key parameter, not tool-selection 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?

Annotations only state that the operation is neither read-only nor destructive, which provides little behavioral insight. The description says 'exchange' but does not disclose whether the original credential is invalidated, whether this is a one-time operation, what authentication context is required, or what capabilities the resulting token carries. For a security-sensitive identity tool, this is a significant gap.

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 with no redundant phrasing and the core action is front-loaded. The jargon density somewhat hurts immediate comprehension, but the conciseness itself is strong for the purpose it does serve.

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 7 undocumented parameters, no output schema, and no lifecycle or usage context, the description is far from complete. An agent would know the intended transformation but would have to guess at parameter formats, optionality, and the meaning of the returned token. This is inadequate for a non-trivial identity exchange 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?

There is 0% schema description coverage and 7 parameters, so the description needed to compensate. It vaguely implies that provider, signature, and timestamp are part of the 'verified provider assertion', but it leaves nonce, subject, capabilities, and display_name unexplained. An agent cannot reliably map all parameters to real-world values from this description.

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 names a specific action ('exchange') and a concrete outcome ('universal principal token'), and it identifies the two acceptable input forms: a verified provider assertion or an existing AgentLot bearer credential. This is more than a tautology, though the heavy jargon and lack of explicit contrast with identity-related siblings like register_agent or connect_public_wallet keep it from being fully self-explanatory.

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 no when-to-use guidance and no exclusions or alternatives. Given the very large sibling list with several identity-adjacent tools (register_agent, connect_public_wallet, get_me), an agent cannot easily determine whether this is the right tool for a given identity-related task without further 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?

Annotations already establish that this is not read-only and not marked destructive. The description adds the useful auth and ownership context that only the authenticated seller's own listings can be imported. However, it does not disclose behaviors like duplicate handling, overwrite semantics, validation outcomes, or partial failure 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 a single, front-loaded sentence with no filler. It communicates the core function immediately and wastes no 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 bulk-import operation with no output schema, no item schema details, and no usage guidance, the description is far too thin. An agent would not know what fields a listing object must contain, what the response looks like, or what happens if some listings fail or already exist.

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