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

Annotations already mark it safe (readOnlyHint=true, destructiveHint=false), and the description adds useful context: the server may act in read-only or signing mode, and this tool only reports that state rather than changing it. It also surfaces marketplace-specific details such as fixed fee and allowlisted contract 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?

One dense sentence packs the return-value list and the usage hint without redundancy. The purpose is front-loaded, and every phrase carries information relevant to calling the 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 no output schema, the description carries the burden of explaining return values, and it enumerates every relevant field plus the network (Stacks mainnet). For a parameterless context tool, an agent has everything needed to call and interpret 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 the schema leaves nothing undocumented and the description needs no parameter elaboration. The description accurately reflects that no inputs are 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 verb ('Show') and resource (who the server acts as on the Nayori marketplace), then enumerates exactly what is returned: signer address, STX balance, read-only/signing mode, registry agents, fixed fee, and allowlisted contract IDs. This clearly differentiates it from siblings like nayori_apply_to_job or nayori_tx_status, which perform or track operations.

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

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

'Call this first' gives explicit placement guidance relative to the other marketplace tools, which is strong context for an agent. It does not spell out when-not-to-use or name alternatives, but for an identity/status tool that is a minor omission.

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 (readOnlyHint false, destructiveHint false) are supplemented with rich detail: it moves no funds, costs no extra service fee, marks the job disputed, describes the resolution outcome, notes that only the SHA-256 of appealReference goes on-chain, and clarifies that a returned txid is not confirmation. This goes far beyond the annotations and provides critical side-effect information.

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

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

The description is a single paragraph but well-structured: it states the purpose first, then conditions, effects, and return behavior. Every sentence adds value, though it is somewhat lengthy. It remains appropriately detailed for a complex write operation without redundancy.

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

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

Given the tool's complexity (write operation with conditions, side effects, and no output schema), the description covers the key aspects: who can appeal, what happens, what goes on-chain, and the meaning of the return value. It does not mention potential error conditions or explicit prerequisites beyond the deadline, but overall it is sufficient 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 only 33% (only appealReference has a description). The description adds meaningful context for appealReference (evidence URL/CID, only its hash goes on-chain) but does not elaborate on asset or jobId. While those parameters are self-explanatory via schema (enum and integer range), the description does not fully 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?

The description opens with 'WRITE (mainnet). Appeal the Evaluator's recorded decision on a job', clearly stating the action, resource, and context. It distinguishes this from sibling tools by focusing on the appeal process, which is unique among the listed operations (apply, submit, etc.).

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

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

It explicitly specifies when to use it: the CLIENT can appeal an approval and the PROVIDER can appeal a rejection, once, until the on-chain deadline. This gives clear conditions for use without naming alternative tools, but the conditions are sufficient for an agent to decide when to invoke it. It does not explicitly say 'when not to use' but the constraints imply 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 indicate readOnlyHint=false (write), destructiveHint=false, and openWorldHint=true. The description adds context beyond annotations by specifying that applying moves no funds, returns a txid, and broadcast isn't confirmation. It also mentions validation conditions (refusal on stale reads). This adds useful behavioral insight without contradicting 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 concise and well-structured. The 'WRITE (mainnet)' prefix immediately signals intent, followed by the action, conditions, note format, and return behavior. Every sentence adds value with no redundancy or fluff. It is appropriately 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 write operation with 4 parameters and no output schema, the description covers the essential aspects: preconditions, side effects, return type, and broadcast caveat. It does not explain the asset parameter's meaning or enumerate possible error scenarios, but given the minimal schema and annotations, it is sufficient for an agent to call it correctly in context.

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

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

Schema coverage is only 25% (only 'note' has a description). The description adds meaning by explaining that agentId must be an active registry agent whose wallet is the signer, and implies that jobId corresponds to an open/funded job. However, the 'asset' parameter is not explained beyond the enum values, and the description doesn't clarify the relationship between jobId and agentId beyond those hints. Given the low schema coverage, the description partially compensates but is not exhaustive.

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: 'Apply to a Nayori job as a provider' and specifies the target ('through job-applications-v1'). It distinguishes this from sibling tools like nayori_register_agent (registration) and nayori_submit_work (submission), and the WRITE prefix clarifies its mutating nature. This is specific and unambiguous.

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

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

The description gives explicit preconditions: 'Refused unless a fresh read shows the job is open or funded with no provider' and 'agentId is an active registry agent whose wallet is the signer.' It also clarifies that this tool does not move funds and that the client must still assign the provider, which implies when a different tool (nayori_client_assign_provider) would be needed. However, it does not name alternative tools explicitly or state when NOT to use it, leaving some inference to the agent.

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

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

Adds important behavioral context beyond annotations: mainnet-only, refusal conditions, result field (hadActiveApplication), no fund movement, and txid not confirmation. This gives the agent a thorough understanding of side effects and response semantics.

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

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

The description is front-loaded with the core action and each sentence adds necessary operational detail. No superfluous 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 simple write tool with 3 required parameters and no output schema, the description covers purpose, preconditions, side effects, and return behavior. It is complete enough 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?

With 0% schema description coverage, the description compensates by explaining that jobId identifies the job and provider is the assignee. The asset enum (sbtc/stx) is self-explanatory, so the added context is sufficient.

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

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

Clearly states the tool writes to mainnet and assigns a provider to a job as a client, referencing the escrow assign-provider operation. This distinguishes it from sibling tools like client_create_job or apply_to_job.

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

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

The description gives explicit refusal preconditions (signer is client, status funded, no provider assigned, provider not disqualified), which effectively tells when the tool will succeed. It doesn't name alternative tools for other scenarios, so not a 5.

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 indicate write (readOnlyHint false) and non-destructive (destructiveHint false). The description adds substantive behavioral details: criteria hashing and commitment, default evaluator, expiry defaults, no fund movement, server cannot fund, and that broadcasting does not confirm. It also clarifies that the job id is obtained via nayori_tx_status, which is extra context. It does not contradict annotations. Minor gap: no explicit mention of permission requirements or reversibility, but given the annotations and richness, 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?

The description is compact but dense, with critical operational constraints front-loaded ('WRITE (mainnet)', 'Act as a CLIENT'). It avoids fluff and every sentence carries operational value. While long, it matches the complexity of a job-creation tool; the structure is logical, moving from purpose to mechanism to constraints. No wasted words.

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

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

For a tool with 6 parameters, no output schema, and significant side effects, the description covers essential context: funding limitations, default evaluator, expiry window, and return semantics (txid vs confirmation). The reference to 'nayori_tx_status' for job id is helpful though slightly cryptic. It adequately equips an agent to avoid common errors (e.g., expecting funding, misinterpreting broadcast as confirmation). Minor omission: no explicit statement about transaction speed or gas, but given the overall thoroughness, a 4 is appropriate.

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 describes parameters with decent coverage (83%). The description adds meaning: acceptanceCriteria must be kept verbatim due to hashing, description has a commitment appended, expiry default, and provider optionality. It clarifies that the criteria are hashed, which is not in the schema. This goes beyond the schema and compensates for the remaining undocumented 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?

States a specific verb ('create'), resource ('evaluable Nayori job'), and scope ('on the escrow', 'Act as a CLIENT'). It clearly distinguishes from sibling tools like nayori_apply_to_job and nayori_client_assign_provider by emphasizing the creation action and the criteria hashing mechanism. An agent can immediately tell this is for initiating a job from the client side.

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

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

Provides explicit context for when to use: as a client on mainnet for creating a job. It warns that the server cannot fund jobs and that funding is a human wallet action, guiding the agent away from expecting fund transfers. It does not explicitly name alternative tools for other actions, but the role and action are unambiguous given sibling context. Slight deduction for not explicitly naming what not to use.

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

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

Annotations only mark readOnlyHint=false, openWorldHint=true, destructiveHint=false. The description adds that this is a 'WRITE (mainnet)' operation, that it 'only records a number', that it 'does NOT pay anything', that it is refused unless the signer is the client on an open job, and that it 'Returns a txid; broadcast is not confirmation.' These behaviors are not derivable from the annotations and provide critical transparency.

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

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

The description is compact yet information-dense, starting with the dominant purpose and then layering precondition, limitation, and return semantics. Every sentence adds a distinct fact with no filler; only the atomic-units sentence partially duplicates the schema's amount description, which is a minor redundancy.

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

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

With no output schema, the description supplies the return type ('txid') and the critical caveat that broadcast is not confirmation. It also covers the mainnet context, the refusal condition, and the limitation that funding is a human wallet action. For a mutating blockchain tool with sparse annotations, this is a complete and thorough definition.

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% (only amount has a description). The description reinforces the atomic-units rule and adds that the amount is a recorded number, not a payment. It also contextualizes jobId as referring to 'a job you created', which is absent from the schema. Asset still relies solely on its enum values, so parameter semantics are improved but not fully elaborated.

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

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

The description opens with 'WRITE (mainnet)' and 'Act as a CLIENT: declare the budget of a job you created (escrow set-budget)', stating the exact action, actor, and underlying mechanism. It explicitly clarifies that it does not pay anything, which distinguishes it from a payment operation, and the sibling list confirms it is the only budget-setting 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 description gives concrete usage preconditions: 'Refused unless a fresh read shows the signer is the job's client and status is 0 (open)' tells the agent exactly when this tool is valid. It also warns that 'Funding the escrow afterwards is a human wallet action that this server cannot perform', preventing misuse as a payment tool. It does not name an alternative sibling, but the conditions are explicit and clear.

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

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

Annotation Contradiction: annotations declare readOnlyHint=true, yet the description explicitly says 'with send:true it also posts it through Nayori's public evaluation relay' and reports '202 = queued', which implies an external side effect rather than a read-only operation. The added context about refusing preconditions and signing nothing is useful, but it cannot resolve the direct 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?

Three dense sentences front-load the core action ('Build the exact JSON body') and then add only high-value constraints, side-effect behavior, response codes, and auth posture. No filler or redundant restatement of the schema.

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

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

For a complex tool with no output schema, the description covers the endpoint, request semantics, preconditions, response hints, and auth requirements. Minor gaps remain: the exact shape of a refusal/error result and the build-only return value are only implied, not stated.

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%, so the description needs to carry some parameter meaning, and it does: it ties acceptanceCriteria and evidence to on-chain commitment/deliverable hashing, and clarifies that send controls whether the body is actually POSTed. jobId and asset are less explained, but the tool-level text gives enough context for them to be understood.

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 and resource ('Build the exact JSON body for ... POST /v1/evaluations') and clearly distinguishes the build-only mode from the optional send mode. It also scopes the tool to a submitted job, so an agent can tell it apart from sibling tools like nayori_provider_submit_committed or nayori_submit_work.

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

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

The description gives clear invocation context: it is for a submitted job and only valid when a fresh read shows status 2, criteria match the on-chain commitment, and the deliverable matches recomputation. It does not explicitly name alternatives or exclusions, but the conditions effectively tell an agent when this tool is applicable.

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 the description reinforces this with 'Read-only'. It adds valuable behavioral context by enumerating the nine status codes, which helps the agent interpret the result. 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?

The description is three short sentences with no filler. The core purpose and parameters are front-loaded, and the status code list is placed where it is most useful. 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?

For a simple read-only tool with two parameters and no output schema, the description is complete: it specifies what is being read, the allowed asset values, the numeric jobId, and the domain-relevant status codes. An agent has enough to invoke it correctly and interpret the likely outcome.

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

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

Schema coverage is 0%, so the description carries the burden of explaining parameters. It states that asset is 'sbtc' or 'stx' and jobId is numeric, which mirrors the schema's enum and integer type but does not add much deeper semantic meaning. This is adequate but not rich parameter guidance.

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

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

Description uses a specific verb ('Read'), names the resource ('one Nayori job from the escrow contract'), and identifies the key parameters (asset and jobId). It clearly distinguishes itself from siblings like nayori_open_jobs, which lists jobs rather than reading a single one.

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 makes clear this is for reading a single job by numeric jobId and asset, and the read-only framing implies it is appropriate for inspection rather than mutation. It does not explicitly name alternative tools or exclusion conditions, but the context is clear enough 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 indicate read-only and non-destructive behavior. The description adds useful behavioral context beyond the annotations by naming the on-chain contract, listing the returned fields, and documenting that withdrawn applications appear with active=false. This helps the agent understand what to expect.

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 the main action and resource front-loaded. The withdrawn-applications detail is valuable. The trailing 'Read-only.' is redundant with the annotations, but this is a minor inefficiency.

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?

Since there is no output schema, the description compensates by listing the returned fields and the active-flag behavior, plus the source contract. It omits things like pagination or ordering and leaves asset semantics to the schema, but for a straightforward listing tool this is largely 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 0%, so the description carries the burden of explaining parameters. It only implies jobId via 'for a job' and does not explain asset (sbtc/stx) or how it affects the listing. The schema's enum and integer range are self-evident, but the description adds little meaning beyond that.

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 ('List on-chain applications') and resource ('job-applications-v1'), with named fields and scope ('for a job'). It is clear and unambiguous, though it does not explicitly contrast the tool with siblings such as nayori_get_job or nayori_open_jobs.

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 implied: call this tool when you need the application records associated with a given job. The note that withdrawn applications appear with active=false aids interpretation of results, but there is no explicit when-to-use, when-not-to-use, or alternative 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 'Read-only.' It adds meaningful behavioral detail beyond annotations: exact statuses (0/1), the 'no provider assigned' condition, and that application counts are included.

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

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

Three concise sentences deliver the core purpose, eligibility rules, parameter hint, and safety note without repetition. Information is front-loaded and every sentence adds value.

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

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

For a read-only list tool with fully documented optional parameters and clear annotations, the description is complete. It states what is listed, the filtering semantics, and the output concept (application counts), so an agent can invoke it correctly without requiring an output schema.

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

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

The schema provides 100% description coverage for both parameters, including the asset enum and limit bounds. The description restates the asset filter semantics but does not need to add more 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 uses a specific verb ('List'), a specific resource ('Nayori jobs'), and precise eligibility criteria ('status 0 or 1, no provider assigned'). This clearly distinguishes it from siblings like nayori_get_job and nayori_list_applications.

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 the context: a provider agent looking for jobs they can still apply to. It does not explicitly name alternatives or when-not-to-use conditions, but the context is unambiguous enough for correct selection.

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?

Beyond the annotations (write, non-read-only), the description discloses important behaviors: it reads the job fresh, refuses unless on-chain conditions hold, computes commitments via @perkos/agent-sdk, emits a specific 36-byte deliverable, and warns that 'broadcast is not confirmation.' This is rich behavioral context that the annotations alone 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?

The description is dense but every sentence earns its place: protocol/network, role, purpose, behavioral checks, output format, parameter semantics, comparison to a sibling, and a caveat. It is front-loaded with 'WRITE (mainnet)' and the core action, and contains 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 write tool with four required parameters and no output schema, the description is complete: it explains refusal conditions, output shape, return value (txid), and the broadcast caveat. It also references the related evaluation tool, giving the agent enough context 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?

With schema description coverage at 50%, the description compensates by explaining the evidence items format, the hashing role of acceptanceCriteria, and the instruction to keep exact inputs for nayori_evaluation_request. It adds semantic meaning beyond the schema, though asset and jobId still rely mostly on the schema definition.

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 and resource: 'submit work for an evaluable job with an evidence commitment (escrow submit-work).' It also distinguishes itself from the sibling nayori_submit_work by naming the exact condition for choosing this tool, so an agent can identify its purpose unambiguously.

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 an explicit routing rule: 'Use this instead of nayori_submit_work when the job description ends with nayori-criteria-v1:.' It also states the prerequisites for a successful call (criteria hash match, assigned provider, status 1), which tells the agent when this tool is appropriate and when it will refuse.

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 write operation (readOnlyHint=false) and non-destructive (destructiveHint=false). The description adds crucial details: 'Costs only the fixed fee' and 'Returns a txid; broadcast is not confirmation', which inform the agent about cost and the non-finality of the return value. These go beyond what 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 concise and well-structured. It begins with 'WRITE (mainnet)' to immediately set expectations, then states the purpose, constraints, cost, and return behavior. Every sentence adds necessary information without redundancy.

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

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

Given the simple schema (two string parameters) and the annotations, the description covers all essential aspects: what the tool does, the constraints on parameters, the cost, and the return value. Since there is no output schema, explaining that it returns a txid and that broadcast is not confirmation is necessary and provided.

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 does provide format details for both parameters ('printable ASCII, 1-64 chars' and 'max 256'), which match the schema but add human-readable constraints. The semantic role of name/description is implied from the tool's purpose, though not explicitly stated, but it is clear enough.

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 'Register' and the specific resource 'agent in the Nayori agent-registry'. It also differentiates from siblings by noting the agent wallet is always the signer address and the endpoint list is empty, which is unique among the listed 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 does not explicitly list alternatives or when-not-to-use, but the purpose is unambiguous given the tool name and description. It clearly indicates this is the registration operation, and the constraints (signer wallet, empty endpoints) imply it's for initial agent setup, providing adequate 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?

Beyond annotations, the description reveals critical on-chain behavior: the deliverableReference is hashed to a 64-character lowercase hex SHA-256, stored as ASCII bytes, that broadcast is not confirmation, and that the response is a txid. There is no contradiction with the readOnlyHint=false, destructiveHint=false, openWorldHint=true 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 dense but every sentence earns its place: operation scope, eligibility conditions, hash semantics, verification advice, and transaction caveat. The 'WRITE (mainnet)' prefix front-loads the most important 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?

For a write tool with no output schema, the description gives enough to invoke correctly: who is allowed, what status is required, what data transformation happens on-chain, what is returned, and the fact that a txid does not mean confirmation. Nothing essential is missing.

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

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

deliverableReference is richly explained (URL/CID/description, trimming, SHA-256 digest, on-chain storage), which adds significant meaning beyond the schema. However, asset and jobId are left to their schema names/enums, and with only 33% schema description coverage the description should compensate more for those 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 states a specific action ('Submit the deliverable') and resource ('the job this wallet is the assigned provider of'), and identifies the underlying operation as 'escrow submit-work'. This clearly distinguishes it from generic tools and other provider-side siblings by naming the exact workflow stage.

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 concrete eligibility rules: the caller must be the job's provider/signer and the job status must be 1 (funded), plus a mainnet scope note. It does not explicitly contrast with alternatives like nayori_provider_submit_committed, so the guidance is context-rich but lacks 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, so the read-only nature is covered. The description adds specific behavioral context by listing the possible statuses and the Clarity result, beyond what annotations provide. No 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?

Two succinct sentences with zero wasted words. The purpose is front-loaded, and the usage hint is appended naturally.

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 one parameter, no output schema, and read-only annotations, the description adequately states what it returns (statuses + Clarity result). It could detail the output structure, but for a simple status check this is sufficient.

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

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

Schema description coverage is 0%, so the description should compensate. It only repeats 'by txid' without explaining the format or meaning beyond the parameter name. The schema's regex pattern provides the format, but the description adds no value for 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 the specific verb 'Check' and names the resource 'a Stacks mainnet transaction by txid', and explicitly lists the outcomes (pending, success, abort) and the additional Clarity result. This is precise and clearly distinguishes it from sibling tools that perform write actions.

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

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

It explicitly states 'Use after any write tool', giving a clear when-to-use condition. It does not mention alternatives, but no sibling tool serves the same purpose, so the guidance is sufficient.

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

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

The description explicitly labels the operation as WRITE on mainnet, warns that broadcast is not confirmation, and discloses the refusal behavior when no application is active. This meaningfully enriches the annotations, which only indicate non-read-only and non-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?

Three short sentences, each carrying distinct value: operation/network, precondition, and return semantics. The most important signal ('WRITE (mainnet)') is front-loaded, 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?

With no output schema, the description correctly supplies the return value (txid) and the key caveat that broadcast is not confirmation. The main missing piece is parameter semantics for asset, but the tool is otherwise adequately characterized for safe 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%, so the description must compensate for parameter meaning. It mentions the job generically but does not clarify what asset selects or what jobId refers to beyond its name. The schema's enum and integer constraints provide limited guidance, but no additional semantics are supplied.

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

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

The description uses a specific verb ('Withdraw') and resource ('this wallet's active application for a job'), and cites the underlying job-applications-v1 withdraw-application operation. This clearly differentiates the tool from siblings like apply_to_job and list_applications.

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

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

The description implies when to use the tool—withdrawing an active application—and states the refusal condition ('Refused if there is no active application'). However, it does not explicitly reference alternatives or direct the agent to first check existing applications via list_applications.

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