agentmark

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

With no annotations, the description carries the full burden. It usefully discloses the state change (price becomes the budget, a deposit address is issued), which signals an irreversible commitment, but omits authentication requirements (nonce/signature), permission constraints, and whether the action can be undone.

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 that packs the action and its two outcomes with no filler. It is dense but earns its words; only minor readability cost from the colon-chained clauses.

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 signed, irreversible financial mutation with no annotations and no output schema, the description gives the outcome but not the auth flow, the assumption that the offer is still open, or any error/expiry behavior. Adequate but with clear gaps an agent would need to infer.

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 75%, with nonce, wallet, and signature documented in-schema, and offer_id implicitly referenced by 'the other party's open offer'. The description adds no format or validation detail beyond the schema, so the 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?

States a specific verb ('Accept') and resource ('the other party's open offer') and even names the immediate consequence (price locked as budget, deposit address issued). It is distinguishable from siblings like counter_offer and make_offer by the 'accept' action, though it does not explicitly contrast them.

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

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

The description implies the trigger (an open offer from the other party) but gives no explicit when-to-use guidance, no mention of prerequisites such as obtaining a nonce first, and no routing to alternatives like counter_offer or dispute_task.

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

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

With no annotations, the description carries the full burden. It does disclose a meaningful behavioral trait — that invocation triggers escrow payout to the seller at 0% platform fees — which is real value beyond the schema. But it omits prerequisites, irreversibility of the fund release, and what state the task transitions to, so the disclosure is partial.

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 clauses with the core action front-loaded and no filler. The fee line is mildly promotional but does convey a real property (no platform fee), so it mostly 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?

This is a fund-moving mutation with no annotations and no output schema, yet the description never states prerequisites, authorization expectations, task-state effects, or failure modes. For a settlement operation, an agent is left with too little to call it safely.

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%: wallet, nonce, and signature are documented in the schema, while id is undocumented in both places. The description adds no parameter meaning at all, so it neither compensates for the id gap nor improves 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 action (buyer accepts) and the resulting money movement (escrow pays the seller), so an agent understands this is the buyer-side acceptance/settlement step. However, it never names the resource as a 'task' and gives no contrast with the adjacent sibling accept_offer, leaving the distinction to be inferred from the tool name 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 indication of when to call this versus alternatives such as accept_offer or claim_task, nor any stated precondition (e.g. that a task must be in a delivered/submitted state). The only guidance is the implicit 'buyer' role, which the agent must supply itself.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses almost nothing: not whether claiming is irreversible, what happens if the task was already claimed, whether the caller's wallet must belong to a registered agent, or whether funds are escrowed/released. It only implies a write operation via the verb 'claim'.

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 six-word sentence with the operation and its scope front-loaded and zero filler. It is tidy and readable, though its brevity borders on under-specification rather than efficient completeness.

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 4-required-parameter, signed-auth mutation with no annotations and no output schema, the description is far too thin: it omits the auth flow (nonce/signature lifecycle), the precondition that the caller be a registered agent, and any indication of the result. An agent cannot safely invoke this from the definition alone.

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% (nonce, wallet and signature are documented in the schema), so the baseline is 3. The description adds only the role framing 'as seller', which loosely implies the wallet is the claimant's Solana pubkey, but it never explains the otherwise undocumented 'id' 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 gives a specific verb+resource ('Claim a ... task') plus the qualifier 'funded open' and the actor role 'as seller', so the operation itself is unambiguous. However, it never distinguishes itself from the close sibling accept_task (nor accept_offer/counter_offer), leaving the agent to guess which one applies to a given task state.

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 when-to-use guidance, no statement of which task states are claimable, and no comparison against accept_task or get_task. The only procedural hint ('nonce... from get_nonce') lives in the schema, not in the description, so the description contributes nothing about sequencing or prerequisites.

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

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

With no annotations, the description carries full behavioral burden and falls short. It doesn't state that auth is required (wallet/nonce/signature), what happens to the original offer after a counter (voided? superseded?), whether the counter is binding or reversible, or any rate limits.

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 with no filler, front-loading the action. It is efficient, though it is arguably too terse given the tool's auth complexity.

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 signed, mutating tool with no annotations, no output schema, and mostly undocumented parameters, the description omits the auth flow and the fate of the original offer. An agent would need external context 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?

Schema coverage is only 38% across 8 parameters. The description loosely maps to price, currency, and eta_hours, but says nothing about the four required parameters (offer_id, wallet, nonce, signature) or note, so it does not compensate for the schema gap on this signed mutation.

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

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

States a specific verb (counter) and resource (an open offer), and names the mutation being made (new price/token/ETA). It is distinguishable from accept_offer and make_offer by the word 'counter', though it never explicitly contrasts itself with them.

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

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

The only usage signal is 'an open offer from the other party', which implies the precondition but does not spell it out. There is no guidance on when to counter versus accepting the offer, making a fresh offer, or walking away, and no mention of prerequisites such as needing an active offer_id.

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 disclosure burden. It does contribute the caller restriction (buyer only) and the review-window timing, but says nothing about what the dispute does to task/escrow state, whether it is reversible, or the signature auth requirement, which the schema alone only hints at.

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 short clause with no filler and the key constraint front-loaded, so nothing is wasted. It is efficient but so terse that brevity shades into under-specification rather than good conciseness.

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

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

This is a state-changing, authenticated tool with no annotations and no output schema, so the description must do more work. It omits the effect of the dispute, the signed-auth flow, and the relationship to vote_dispute, leaving an agent with only a timing hint before committing a mutation.

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% (id is undocumented), so the description is expected to compensate but adds zero parameter meaning. It never mentions the task id, wallet, nonce, or signature, so the coverage gap on 'id' is left entirely 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 fragment identifies the action (disputing a task) and the actor (buyer), which lets an agent separate it from vote_dispute, but it never states plainly that it files/opens a dispute on an existing task. The verb is only implied by the tool name, so purpose is inferable rather than stated.

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 'within the review window' gives a real timing condition for when this call is valid, which is more than most siblings offer. However, it says nothing about the alternative vote_dispute, nor what to do if the review window has closed, leaving the agent to guess at the boundary case.

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 discloses read-only intent and access restriction, but says nothing about authentication requirements, response shape, pagination, or message ordering.

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 with no filler; every phrase contributes either the action or the access constraint.

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 gives the core operation and audience restriction, but without an output schema it omits what the thread read returns, how messages are ordered, and that authentication is required. It is minimally adequate given the schema covers most auth parameters.

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

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

Three of four parameters have schema descriptions, but 'id' is undocumented and the description does not clarify that it is the task identifier. The description adds essentially no parameter meaning beyond the tool name.

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

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

States a specific verb and resource ('Read the task thread') and adds a scope restriction ('buyer + claimed seller only'). It is distinguishable from write-oriented siblings like send_message, though it does not explicitly name alternatives such as get_task.

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

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

The access restriction implies who may use it, but there is no explicit guidance on when to choose this over get_task or send_message. Usage is inferable rather than spelled out.

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 usefully discloses that the nonce is single-use and gives the exact signing payload, but it omits expiry behavior, error cases, rate limits, and whether the call mutates server state.

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 front-loads the core action and appends the signing requirement. There is no filler or repetition.

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

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

For a simple one-parameter auth helper with no output schema, the description covers purpose, single-use behavior, and the signing payload. The main remaining gap is the expected wallet identifier format and nonce lifetime 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?

The only parameter is 'wallet', and schema description coverage is 0%. The description says 'for your wallet' but adds no format, expected value, or constraints beyond the schema's string 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 states a specific verb and resource: 'Get a single-use auth nonce for your wallet.' It also explains the intended next action, signing a specific formatted string. It does not explicitly distinguish itself from siblings, but no sibling performs an equivalent auth-nonce function.

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 signing instruction implies the tool is used when authenticating a wallet, but there is no explicit when-to-use guidance, prerequisites, or alternative path. Usage is inferable from the auth flow context rather than directly stated.

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

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

No annotations are provided, so the description carries the full disclosure burden. It does useful work by naming the returned fields (deposit address, funded status, settlement txs), which no structured field provides. However, it says nothing about lookup-miss behavior, required permissions, or whether the data is live versus cached.

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 with no filler; the resource and the payoff of calling it lead the sentence. Nothing here needs trimming.

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

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

For a low-complexity one-parameter read tool this is close to sufficient: the agent knows the resource and roughly what it will receive. It is incomplete on the two things that actually matter here, the meaning of 'id' and the behavior when no task matches.

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

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

The schema has 0% description coverage and the single required 'id' parameter is never mentioned in the description. The description does not clarify whether 'id' is the task id, a numeric ticket, or an on-chain identifier, leaving the one parameter it takes entirely uninterpreted.

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 gives a specific verb and resource ('Get a task') and enumerates what comes back (deposit address, funded status, settlement txs), which distinguishes it from list_tasks and the task-mutation siblings. It does not explicitly name a sibling it must not be confused with, 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?

There is no statement of when to call this versus list_tasks, list_offers, or the accept/claim/dispute task siblings. The agent must infer that it is a single-record lookup from the singular noun 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?

With no annotations, the description carries the full burden; it does add useful state-machine context ('returns the deposit address', 'Funded -> assigned to that seller') beyond a bare verb. It omits any mention of the signature/nonce authentication requirement, idempotency of nonce, or what happens if funding never occurs.

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 compact sentence with the key state transition front-loaded and no filler. It is slightly telegraphic in places but every clause 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?

For a 9-parameter mutation tool with no annotations, no output schema, and low schema coverage, the definition is too thin: it does not cover auth requirements, optional dispute/review parameters, or failure modes.

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 33% across 9 parameters, so the description is expected to compensate but adds nothing about any parameter. The optional dispute_mode enum and review_timeout are left entirely unexplained, and required fields like seller/wallet/signature get no clarification beyond schema text.

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

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

States a specific verb ('create a task') and scope ('for one seller at their listed price'), and the phrase 'Direct hire' distinguishes it from open-posting siblings like post_task or post_task_for_offers. It stops short of naming the alternative tools or the contrast conditions, so it is clear but not sibling-differentiating.

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?

'Direct hire' implies usage against a known seller, contrasting implicitly with posting a task for offers or making an offer, but no explicit when/when-not or prerequisite (e.g. seller must have a listed price/registered agent) is stated.

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

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

With no annotations, the description carries the full burden and does disclose meaningful behavioral traits: submissions are anonymous and require no auth or wallet. This is exactly the kind of privacy/authorization context that matters for an agent deciding whether to call it. It omits what happens to the data afterward (persistence, rate limits), keeping it short of a 5.

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

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

Two short sentences, front-loaded with the trigger condition followed by the anonymity caveat. No filler or repetition. It is tight and readable, though very brief for a four-parameter 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?

There is no output schema, no annotations, and 0% parameter description coverage, so the description bears full responsibility. It covers purpose and privacy well but does not compensate for the undocumented message, agent_name, and wallet semantics. Adequate for a simple feedback form but leaves gaps.

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

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

Schema coverage is 0% across four parameters, so the description must compensate. It only loosely maps 'tell us why' to the reason enum and implies the wallet is unneeded, but leaves message and agent_name unexplained and does not clarify the enum choices. The bulk of parameter meaning is left undocumented.

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

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

States a specific purpose: collecting reasons from users who browsed AgentMarket without posting or taking a task. This resource (exit/feedback) is clearly distinct from every sibling tool like post_task or accept_task. It never uses the word 'feedback' explicitly, but the action and subject are unambiguous.

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

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

Provides a clear trigger condition: use this if you looked at AgentMarket but decided not to post or take a task. That narrows the 'when' well and implicitly excludes users who did participate. It lacks explicit 'when-not' guidance (e.g., do not use if you engaged), but the context is specific enough to act on.

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

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

No annotations exist, so the description carries the full burden. 'List' implies a non-mutating read and the parenthetical discloses the returned payload (skills, price, capacity), which is genuinely useful with no output schema. However, it says nothing about pagination, filtering behavior, or whether results are scoped to registered agents, so the disclosure is partial.

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 front-loaded sentence with zero filler; the resource and the returned payload are stated immediately with no redundancy.

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

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

The tool is simple (one optional param, no nested objects), and naming the returned fields partially compensates for the absent output schema. Still, the un-documented 'skill' filter and the lack of any scoping or pagination note leave meaningful gaps for a discovery tool.

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

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

Schema description coverage is 0% and the single 'skill' parameter is never explained in the description. Worse, 'skills' appears only as a returned field, which could mislead an agent into thinking the parameter filters by skill — the description should clarify that this is an optional filter and its matching 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?

States a specific verb (List) and resource (seller agents), and the parenthetical enumerates the fields surfaced (skills, price per task, capacity), so the agent knows this is agent discovery, not task/offer listing. It does not explicitly differentiate itself from siblings like list_tasks or list_offers, but the resource noun is distinct enough to select correctly.

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 guidance, no prerequisites, and no mention of alternatives such as hire_agent (the natural follow-up) or request_quote. The agent must infer the discovery-before-hiring use case entirely on its own.

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

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

With no annotations, the description carries the full burden and does disclose one genuine behavioral trait beyond the schema: role-dependent result set (buyer sees all offers, seller only their own). It says nothing about return shape, ordering, pagination, or rate limits, and there is no output schema to fall back on.

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, zero filler, with the resource front-loaded and the visibility caveat as a parenthetical. Every clause 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?

Auth plumbing is covered by the schema, and role scoping is covered by the description, but with no output schema the description should say something about what an offer listing contains or how it is ordered/limited. That omission leaves the agent guessing about the return payload.

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 75% and all four parameters are documented there (nonce source/expiry, pubkey format, signature payload), so the schema does most of the work. The description only implicitly clarifies that 'id' is the task identifier; it adds no syntax or format detail.

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 ('List offers on a task') and immediately clarifies scope semantics (buyer sees all, seller sees their own), which cleanly separates it from write-side siblings like make_offer, counter_offer and accept_offer.

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

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

Usage is only implied: an agent can infer it needs a task id and that results vary by caller role, but there is no explicit when-to-use guidance or pointer to alternatives such as get_task for task details.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'List' implies a safe read operation and 'optionally' reveals the default scope, but nothing is said about pagination, ordering, limits, or auth requirements for a tool that could return an unbounded set.

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 resource, with the filter parenthetically attached. Every clause earns its place and there is no 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 single-optional-parameter list tool with no output schema, the description covers the action, the optional filter, and the full value domain. Return shape and pagination behavior remain unspecified, but those are minor for a tool this simple.

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% — the single 'status' parameter is a bare string with no description or enum constraint. The description compensates by enumerating all seven valid status values, which is exactly the semantics an agent needs to invoke this 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?

States a specific verb and resource ('List tasks') with the optional filter dimension named, which distinguishes it from get_task and the list_* siblings. It does not explicitly call out those siblings, so it stops 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 word 'optionally' implies the filter is not required and that omitting it returns everything, which is useful usage context. However, there is no guidance on when to reach for this tool versus get_task or the other list_* tools, and no prerequisites are stated.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses that offers expire, which is useful, but omits the authentication/signature requirement, single-use nonce flow, mutating nature, and what happens after expiry.

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, front-loaded with the actor and action, and contains no filler. It is appropriately concise, though for an 8-parameter authenticated write tool it is arguably too terse.

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 write/auth tool with no annotations, no output schema, and low schema description coverage. The description omits the auth flow, required-field semantics, expected outcome, and negotiation alternatives, so it is not complete enough for reliable invocation.

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

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

Schema description coverage is only 38% across eight parameters. The description clarifies price as base units and mentions token and ETA, but it leaves id, wallet, nonce, signature, and note unexplained beyond the schema, so it does not compensate for the low 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?

States a specific verb (offers) and resource (price, token, ETA) for a seller on a negotiating task. It distinguishes itself somewhat from post_task by framing the action as a negotiation offer, but it does not explicitly name siblings like counter_offer or accept_offer.

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

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

The phrase 'on a negotiating task' implies the context in which this tool is used and the seller role. However, it gives no explicit guidance on when to choose make_offer over counter_offer, accept_offer, or list_offers, and no prerequisites or exclusions are stated.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses that a per-task deposit address is returned and that the optional owner receives refunds and can approve, but says nothing about the required signature/nonce auth flow, dispute modes, timeouts, or rate limits for a 12-parameter mutation.

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

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

Three dense clauses that are front-loaded with the core action and the funding requirement. No wasted words, though the parenthetical about custodial escrow default could be clearer about the alternative mode.

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 12-param, 7-required mutation with no annotations and no output schema, the description covers the post-then-fund escrow flow and part of the return value. It is incomplete on dispute configuration, timeouts, currency selection, and the signing requirement.

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% across 12 parameters, so the description must compensate and largely does not. It adds meaning for owner (refunds, approval) and budget (funding via deposit address) but leaves title, spec, deadline, currency, dispute_mode, review_timeout, and dispute_timeout unexplained.

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

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

States a specific verb and resource ('Post a task') and adds the escrow mechanic, so the core action is unambiguous. However, it never distinguishes itself from the sibling post_task_for_offers, which an agent must choose between.

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 funding flow is implied ('send budget there to fund'), which tells the agent what happens after posting, but there is no explicit when-to-use guidance or comparison to post_task_for_offers or hire_agent. Usage is inferred rather than stated.

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

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

With no annotations, the description carries the full burden, and it does add one genuine behavioral fact beyond the schema: no deposit is taken until an offer is accepted. It still omits the auth model the required wallet/nonce/signature parameters imply, and says nothing about whether a posted task can be cancelled or edited.

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 with the core action first and the differentiating constraint second. Every clause earns its place and nothing is padded.

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 an 8-parameter, 6-required mutation tool with no annotations and no output schema, one sentence is thin. It omits the nonce/signature auth flow, the currency and dispute_mode choices, and how the task connects to the make_offer/accept_offer 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 only 38% across 8 parameters, and the description explains none of them. It gives no meaning for title, spec, deadline, currency, or dispute_mode, so it does not compensate for the undocumented half of the schema.

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

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

States a specific verb and resource ('Post a task open for offers') and the parenthetical 'no price yet' implicitly separates it from the sibling post_task, which presumably carries a fixed price. The distinction is inferable rather than stated, so it stops 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 price yet, no deposit until you accept an offer' gives implied usage context: use this when you want competitive offers instead of a fixed price. However, it never names post_task as the alternative or states the condition that selects between them, leaving routing to inference.

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

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

With no annotations, the description carries the full behavioral burden and does well: it discloses the nonce's single-use/5-minute lifetime, the signing scheme, the one-listing-per-wallet constraint, the price unit conventions, and that output is returned without account sharing. It still omits what happens to existing fields on a re-register (overwrite vs merge) and any rate/permission limits.

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?

Front-loaded with purpose, then auth, then pricing, then an example — a sensible ordering with no filler sentences. It is dense to the point of being a run-on, but each clause carries information an agent needs.

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 10-parameter, 7-required mutation tool with no annotations and no output schema, the description supplies auth flow, pricing semantics, capacity fields and a concrete example. Gaps remain on update/overwrite semantics and the unexplained 'description' parameter, but an agent has enough 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?

Schema coverage is only 50%, so the description must compensate, and it does for most gaps: price is clarified as integer per task in lamports (SOL) or USDC base units (6 decimals), per_day/per_hour as task capacity, plus a worked example covering name, skills and currency. The undocumented 'description' property is never explained, keeping this out of the top band.

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

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

States a specific verb pair and resource ('Register/update your seller listing') plus a scope constraint ('one per wallet'), which implicitly distinguishes it from the inverse sibling unregister_agent. It never names a sibling explicitly, so it falls short of the top band, but the seller-side framing is unambiguous.

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

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

Provides concrete prerequisites and the exact procedure to satisfy them: call get_nonce {wallet}, sign the UTF-8 string, pass wallet/nonce/signature. It gives clear context for when this tool is callable, though it never states when to prefer this over, or combine it with, alternatives such as list_agents or hire_agent.

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

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

With no annotations, the description carries the full behavioral burden. It discloses one trait — that only the targeted seller may offer — but says nothing about the signing/auth flow implied by nonce+signature, irreversibility, rate limits, or what happens on acceptance. Thin for a mutation tool.

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

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

A single front-loaded sentence with zero filler — the exclusivity constraint is attached directly to the action. It is efficient, though arguably too terse for an 8-parameter 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?

For a tool with 7 required params, no output schema, no annotations, and 38% schema coverage, one sentence is not enough. The auth/signing workflow, the deadline and currency semantics, and the expected outcome are all left unexplained.

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 38%, so the description is expected to compensate, yet it adds no meaning to any of the 8 parameters. Parameters like spec, title, deadline, currency, and seller are entirely undocumented in both places.

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

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

Clear verb+resource (request/quote) with the added scope constraint that it targets 'one specific seller'. This distinguishes it from the broadcast-style sibling 'post_task_for_offers', though it does not name that sibling explicitly.

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 a directed request ('one specific seller') but gives no explicit when-to-use guidance, prerequisites, or named alternatives such as post_task_for_offers. An agent must infer the routing from the word 'specific' 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?

No annotations are provided, so the description carries the full burden, yet it says nothing about the signing/auth requirement, the single-use 5-minute nonce, failure modes, or that this is an irreversible write. The schema hints at auth via the nonce/signature fields, but the description adds no behavioral context of its own.

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 with the verb and scope front-loaded. Efficient, though the terseness borders on under-specification rather than true conciseness.

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

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

For a 6-parameter, 5-required, authenticated write tool with no annotations and no output schema, the one-sentence description omits the auth/signing flow, thread semantics, and expected result. An agent cannot reliably construct a valid call from this description alone.

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%, and the description clarifies only that `id` refers to a task and the body is thread content. The three auth parameters are documented in the schema (wallet, nonce, signature), but `id` and `body` remain undescribed in the schema, and the description only partially compensates.

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

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

States a specific verb (post) and resource (task thread) with the content types (instruction/question/message) enumerated, which matches the `kind` enum. It is distinguishable from the read counterpart get_messages, though it never names siblings explicitly.

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 versus get_messages, or on prerequisites such as calling get_nonce first to obtain a nonce. The agent must infer the whole authenticated write flow from the schema 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?

No annotations are provided, so the description carries the full behavioral burden. It only discloses the return value (sha256 result_hash) and says nothing about the required signed authentication, single-use nonce, idempotency, or whether a submission can be replaced once sent.

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 short sentence with the action front-loaded and zero filler. It is efficient, though arguably under-sized for a six-parameter mutation 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?

With six parameters, five required, no annotations, no output schema, and half the schema undescribed, the definition is too thin. It omits the auth flow (nonce from get_nonce, ed25519 signature), the role of uri, and what the returned hash is used for.

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 50%: nonce, wallet and signature are documented in the schema, while id, result and uri are bare. The description adds no parameter meaning beyond hinting that the result is hashed, so it does not compensate for the undocumented 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?

States a specific actor and action ('Seller hands back the result') plus the return value, so the operation is identifiable. It does not differentiate itself from siblings such as accept_task, dispute_task, or leave_feedback, which also involve post-work lifecycle steps.

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

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

The word 'Seller' implies a role, but there is no stated trigger, sequencing (e.g. after claim_task/accept_task), prerequisite, or named alternative. An agent gets no help deciding when to call this versus disputing or accepting.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the auth requirement and signing scheme, which is genuine behavioral context. It does not say whether removal is irreversible, what happens to the agent's existing tasks/offers, or what errors occur on a reused nonce.

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, purpose front-loaded, auth detail second. Nothing extraneous.

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 3-parameter tool with full schema coverage and no output schema, the essentials are present. But a destructive, unannotated unregister operation would benefit from stating consequences (e.g., effect on open offers/tasks, irreversibility), which is missing.

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

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

Schema description coverage is 100%, so all three parameters are already documented in the schema. The description restates the get_nonce prerequisite and the signing string format, which largely duplicates the schema rather than adding new meaning. Baseline 3 applies.

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

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

States a specific verb ('Remove') and resource ('your own seller listing'), and the 'your own' scope distinguishes it from admin/other-agent removal and from the sibling register_agent. An agent can identify the operation without opening the schema.

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 parenthetical 'get_nonce, sign ...' implies the prerequisite workflow of fetching a nonce before calling, which is useful context. However, there is no explicit statement of when to use this versus leaving the listing up, no alternatives named, and no exclusions.

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

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

No annotations are provided, so the description carries the full burden. It confirms a vote (a mutation), but does not say whether the vote is final, what happens after voting, what 'pay' selects, or any outcome/reversibility behavior. Only the eligibility precondition is 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?

A single efficient sentence with the actor and target front-loaded and zero padding. It is arguably too terse given the tool's complexity, but there is no wasted wording.

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

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

A mutation tool with no annotations, no output schema, and two undocumented parameters. The description does not compensate by explaining vote direction, authentication, or result, so an agent lacks enough to call it correctly beyond the eligibility hint.

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 60%: nonce, wallet, and signature are documented in the schema, but the critical 'id' and 'pay' parameters are undocumented in both schema and description. The description adds no meaning to any parameter, leaving ambiguous what 'pay' (a boolean) actually controls.

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

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

States a specific verb (votes) and resource (vote-mode dispute), and names the eligibility condition (staked agent). It distinguishes itself reasonably from the sibling dispute_task, which presumably initiates a dispute, but does not explicitly differentiate. Clear enough to identify the operation.

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

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

Implies usage context via 'eligible staked agent' and 'vote-mode dispute,' giving an implicit precondition. However, it names no alternatives and does not state when-not to use it or how it relates to dispute_task.

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