RTK Motion — Motion Capture, Biomechanics, Threat & Fleet Intelligence

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

With no annotations, the description carries the full burden and does well: it reveals the read-only nature implicitly via 'browse', discloses pricing expectation ('Free, no payment required'), and describes output behavior for each input case. It omits edge-case behavior (invalid path, pagination, error handling), but the core behavioral traits are transparent.

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

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

Three sentences, each delivering distinct value: what it browses, the path-hierarchy behavior, and the pricing guarantee. No filler or repetition of schema information; it is front-loaded and compact while packing meaningful detail.

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

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

Given a single optional parameter, no output schema, and no annotations, the description covers the essential scenarios (root, category, lesson) and even mentions pricing and MCP tool names, which is valuable contextual linkage to sibling tools. It could be more complete by addressing error cases or result formatting, but it adequately sets expectations for a browse operation.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by explaining how different path formats (root, category, lesson) map to different result types, effectively providing semantics that the parameter description alone does not convey.

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

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

The description uses a specific verb ('browse') plus resource ('hierarchical catalog') and explicitly enumerates the dataset categories (motion-capture, threat-intel, rehab-biomechanics). It clearly distinguishes from sibling get_* tools by focusing on hierarchy traversal rather than file retrieval, and from search_catalog by presenting a path-based browse paradigm.

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 usage context by defining behavior for three path scenarios: no path (root categories), category path (children), and lesson path (file inventory, pricing, MCP tool names). It does not explicitly mention alternatives ('use instead of...'), but the path-dependent semantics imply when this tool is appropriate versus search or direct retrieval.

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 well: it discloses exactly what is included, what is excluded (rigged FBX/OBJ mesh assets), the price, accepted chains, and payment method. It does not explain post-payment behavior, such as how files are delivered or whether access is time-limited.

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 front-loads the key idea — complete bundle contents — before moving to payment logistics. Some payment address details duplicate the schema, but the overall length is justified for a high-stakes purchase 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 complex, payment-gated purchase tool with no output schema, the description covers the core contents, exclusions, price, and payment rails well. It still leaves the return behavior vague, since it does not state what the caller receives after a successful payment.

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

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

Schema description coverage is 100%, so the baseline is 3. The description mentions payment methods and the $50 price, but most of that detail is already present in the payment_tx and x_payment schema descriptions; it adds little parameter-level meaning beyond the schema.

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

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

The description clearly identifies the resource and scope: a complete session bundle containing every modality for one lesson in a single purchase, with specific file counts and formats. It implies differentiation from single-modality siblings like get_bvh and get_video_url by saying it includes EVERY modality, but it does not explicitly name those alternatives.

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 clear purchase context and precise payment instructions for Base and Solana, including the amount and wallet addresses. However, it never explicitly states when to use this bundle versus individual modality tools such as get_bvh or get_robotarget; that choice is left implicit.

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 well: it discloses price ($10 USDC), chain/wallet, latency (<500ms), 60fps, joint hierarchy, and offers an alternate x402 payment route. It omits failure modes (what happens on invalid tx hash, whether payment is verified before or after data fetch), which keeps 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?

Three dense sentences, front-loaded with what the asset is and its specs, then payment mechanics, then the cheap alternative. No filler despite carrying a lot of 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 5-param paid tool with no output schema and no annotations, the description covers cost, delivery protocol, and quality specs well. It does not describe what is actually returned (file/inline data, manifest, lesson scoping), which an agent needs when there is no output schema.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters. The description restates that the tx hash goes in payment_tx but adds no format or validation detail beyond the schema, so the 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 the resource concretely ('BVH skeletal animation') and names its target use cases (robotic_grappling_training, imitation_learning). It also implicitly distinguishes itself from get_trial_bvh as the paid full version. Lacks an explicit verb like 'retrieve', but the resource+format 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?

Explicitly routes budget-conscious callers to get_trial_bvh as a cheaper alternative, and explains the payment paths. However, it gives no guidance on when to prefer get_bvh over other content siblings like get_mocap_sample or get_robotarget, or how lesson_path selection should be driven.

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

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

With no annotations provided, the description carries the full burden. It discloses the return format (` .calib` file as text) and the 'FREE' aspect, which adds value. However, it does not mention potential error conditions or explicitly confirm a read-only operation, though the 'get' verb and output format imply this.

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

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

The description is two sentences, front-loaded with the key phrase 'FREE multi-camera calibration parameters', and every sentence contributes useful information without waste. It achieves a high signal-to-noise ratio.

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 getter with one optional parameter and no output schema, the description covers purpose, usage context, and return format. It could add a note about missing lesson behavior, but the overall completeness is sufficient for an agent to decide and invoke correctly.

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

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

The schema provides 100% coverage for the single optional parameter `lesson_path`, including an example and default behavior. The tool description adds no additional parameter meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

The description clearly identifies the tool as retrieving multi-camera calibration parameters (intrinsics and extrinsics) for the capture rig, using a specific verb+resource phrasing. It distinguishes from sibling tools by specifying the exact asset (calibration file) and context (reprojection, retriangulation, rendering).

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

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

The description explicitly states the tool is 'required' for pipelines that reproject, retriangulate, or render against original capture geometry, providing clear when-to-use context. It does not name alternatives or exclusions, but the use case is unambiguous and distinct from sibling get_* tools.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It reveals that the sample is free, limited to 5 seconds, and intended for validation. It also notes the paid full-file option. While it doesn't describe the exact return format or any potential side effects, it gives substantial context for a read-only sample tool.

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

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

Two concise sentences front-load the key facts (FREE, first 5 seconds) and pack in use cases and an alternative. Every word earns its place with no redundancy.

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

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

For a simple tool with two optional parameters and no output schema, the description fully covers what the tool does, its limitations, pricing, and use cases. It is complete enough for an agent to select and invoke it correctly.

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

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

Schema coverage is 100% (both parameters have descriptions), so the baseline is 3. The description adds minimal extra meaning beyond the schema, though it does mention 'lesson fps', which subtly ties to lesson_path. No further parameter detail is needed given the self-descriptive schema.

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

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

The description clearly states the tool's function: providing a free 5-second BVH motion capture sample. It includes specific details (frame count = 5 × lesson fps) and distinguishes it from the full-file alternative (get_bvh), making the purpose 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 explicitly mentions use cases (validating format, joint hierarchy, data quality for sim_to_real_retargeting or action_recognition) and points to the alternative get_bvh for full files (20–120 seconds, $10 USDC). This provides clear guidance on when to use this tool versus the sibling tool.

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

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

With no annotations provided, the description carries the full transparency burden. It discloses that the tool is 'Free' and intended for pre-purchase evaluation, which adds some behavioral context. However, it does not mention response format, data completeness, or any operational limitations, leaving room for additional disclosure.

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

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

The description is a single, concise sentence that front-loads the primary content and use case. Every word adds value, with no redundancy or filler.

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

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

Given this is a simple get operation with one parameter and no output schema, the description sufficiently covers the tool's purpose, content, and usage context. It could mention the return format, but that is not critical for a free evaluation profile. The description is complete enough for an agent to select and invoke this tool appropriately.

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

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

The schema description covers 100% of parameters, providing a clear example for case_path. The tool description adds general context about the content (demographics, injury history, medications) but does not elaborate on parameter-specific semantics beyond what the schema already offers, aligning with the baseline.

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

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

The description clearly states the tool returns patient demographics, injury history, and medications for a rehab case. It differentiates from sibling tools by highlighting it is free and used for evaluating case relevance before purchasing reports, making the purpose 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 explicitly instructs when to use this tool: 'evaluate case relevance before purchasing biomechanical reports' and specifies the use cases (insurance_claim_validation, PT_outcome_measurement). It does not directly name alternative sibling tools, but the context implies its role as a preliminary assessment, which is clear enough.

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

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

No annotations are provided, so the description carries the full behavioral burden and does disclose substantial context: price ($0.25 USDC), chain/token/wallet, payment_tx mechanism, latency (<200ms), and output formats. It still omits read-only/non-destructive semantics and error behavior, which prevents a 5.

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

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

The definition is front-loaded with the report's purpose, metrics, and formats, and the payment details are relevant to invocation. It is dense but not redundant; however, the payment block slightly crowds out sibling differentiation.

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

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

With no annotations and no output schema, the description must cover behavior, cost, and return content, and it does provide metrics, formats, latency, and payment mechanics. It leaves sibling selection and detailed error/return structure unaddressed, so it is strong but not complete.

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

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

Schema description coverage is 100%, and the schema already documents all five parameters including the payment alternatives. The description only adds payment context for payment_tx (price and wallet) and does not add meaning beyond the schema for case_path, exercise, x_payment, or quote_id, so the 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?

It names a specific resource, a per-exercise biomechanical report, and enumerates the report contents and intended use cases, so the agent can tell what it returns. It does not distinguish itself from sibling rehab-report tools such as get_rehab_summary, get_rehab_profile, or get_rehab_sample, which keeps it 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 phrase 'for PT_outcome_measurement or medical_insurance_review' provides intended-use context, but there is no explicit guidance on when to choose this tool over similar sibling tools or when not to use it. The guidance is therefore implied rather than fully actionable.

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 that the sample lacks numeric values. However, it does not describe the actual response format, potential errors, or other behavioral aspects beyond the absence of numbers, leaving some ambiguity.

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 (four sentences) and front-loaded with the core purpose. Every sentence adds useful information: the free nature, the structural output, the upgrade path, and a concrete usage example. No redundant or wasted text.

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

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

For a simple sample tool with one optional parameter and no output schema, the description covers the essential aspects: what it returns (structure, categories, no numbers), the cost difference, and an example. It does not describe the exact response structure, but given the tool's simplicity and the pointer to the full version, it is reasonably complete.

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

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

The schema already fully documents the single parameter with a description and default value. The description adds value by providing an example value, which helps the agent understand what a valid case_path looks like beyond the schema.

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

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

The description clearly states the tool shows the structure and metric categories of a clinical summary without numeric values, which is a specific verb+resource+scope. It distinguishes itself from get_rehab_summary by noting that the summary provides full numeric data.

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

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

The description explicitly recommends using get_rehab_summary for full numeric data and provides a concrete example case_path for trying the sample. It implies when not to use this tool (when numeric values are needed) but does not exhaustively cover all sibling tools.

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

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

With no annotations, the description carries the burden and does well: it discloses the $0.50 USDC price, chain and wallet, the accepted payment payloads (payment_tx, x_payment, quote_id), and latency <300ms. Auth/permission nuances beyond payment and failure behavior are not addressed, keeping it below 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?

Purpose and capability list are front-loaded, with payment mechanics after. It is dense but coherent; the only minor waste is repeating wallet/price details that the schema also carries.

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

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

No output schema exists, so the description must convey return content — it lists the concrete data elements and both formats (JSON + TXT). Pricing and case_path example are covered. It falls short only on edge cases like invalid case_path or failed payment.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters including the payment variants. The description's payment paragraph restates what the schema says (payment_tx, quote_id semantics) rather than adding new parameter meaning, so 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+resource ('cross-exercise biomechanical summary') and enumerates its contents: asymmetry indices, ROM, fatigue markers, clinical synthesis. However, it never distinguishes itself from the close sibling get_rehab_report, leaving the agent to guess which summary/report to pick.

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 names two usage contexts ('insurance_claim_validation' or 'rehab_progress_tracking'), which implies when to reach for it. But it gives no exclusions and does not explain how it differs from get_rehab_report or get_rehab_profile, so the routing decision is only partly supported.

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

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

With no annotations, the description carries the burden well: it discloses output format (NPZ), compatibility (MoveIt/ROS, Isaac Sim), frame rate, latency, and the payment flow including Base USDC and x402 alternatives. It still omits error/refund behavior and file-size or delivery details, so it is strong but not exhaustive.

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 and front-loads the resource and platforms before payment instructions. Most sentences earn their place, though the Ethereum/Solana pointer and repeated payment details add slight clutter.

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 paid, multi-parameter retrieval tool with no output schema, the description covers the essential output format, compatibility, latency, platform options, and payment workflow. It is nearly complete, with only minor gaps around file contents and failure handling.

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 parameter meanings are already well documented. The description reinforces the robot and payment_tx parameters but adds little semantic detail beyond the schema, making the baseline 3 appropriate.

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

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

The description identifies the resource as multi-robot joint trajectories in NPZ format and gives concrete use cases (sim_to_real_retargeting, imitation_learning). It also distinguishes the full tool from the cheaper get_trial_robotarget sibling, though it does not use an explicit retrieval verb.

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 names appropriate use cases and explicitly points to get_trial_robotarget for a cheaper $0.25 trial sample. It does not fully articulate when the full paid tool is required versus when the trial is sufficient, 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?

With no annotations, the description carries the full burden and does a lot: per-frame plate-blurring policy, the caveat that MOST frames have no legible plate, that `equipment` is capture-derived/approximate, and that no plate text/state exists anywhere. It omits failure modes, whether repeat calls re-charge the $5, and URL expiry duration, so it stops 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?

The payload description and the 'buy this for the sighting trail' steer are front-loaded, correctly prioritized over payment mechanics. It is dense but nearly every sentence carries a distinct constraint; the payment paragraph could have been split out or deferred to schema descriptions.

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

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

There is no output schema, so the description must describe returns, and it does — sighting trail fields (USDOT, carrier, equipment, geo, timestamp) plus time-limited signed crop URLs, with the blur caveat. Missing only operational detail such as result limits, pagination, or URL lifetime.

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 already 100%, so the baseline is 3. The description still adds real value by supplying the payment specifics for payment_tx/x_payment: $5 USDC, chain 8453, the exact token and receiving wallet, and the .well-known/x402 pointer for Eth/Solana — none of which the schema conveys.

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

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

States a specific verb and resource — returns the commercial-carrier sighting trail plus signed crop URLs — and enumerates the three investigative tasks it serves. It also explicitly distinguishes itself from the sibling get_spotter_carrier_profile, which it describes as the free evaluation alternative.

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

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

Tells the agent exactly when to buy this ('buy this for the sighting trail, not for plates') and names get_spotter_carrier_profile as the free-evaluation alternative. It also states an eligibility exclusion (commercial carriers only, owner-operators excluded), which is a genuine when-not condition.

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 transparency burden. It discloses that the tool is free, that it is a preview/assessment step before purchase, and enumerates the returned data categories. It does not explicitly state read-only behavior or potential error conditions, but the 'before purchasing' phrasing strongly implies a non-destructive, informational operation.

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

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

The description is a single, dense sentence that front-loads the core purpose and enumerates useful output fields and use cases. Every clause earns its place, with no redundant or filler content.

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

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

Given the simple one-parameter input and no output schema, the description sufficiently describes both the input context and return contents (USDOT, FMCSA name, class, counts, geo coverage). It also explains the business purpose, making it complete for an agent to select and invoke the tool appropriately.

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

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

There is one parameter, `usdot`, and the schema already provides a clear description and example ('USDOT number, e.g. 054283') with 100% coverage. The tool description mentions USDOT as part of the output but adds no additional semantic meaning to the parameter beyond what the schema already supplies.

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

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

The description clearly identifies the tool as returning a commercial-carrier sighting profile with specific data fields (USDOT, carrier name, class, counts, geo coverage). It distinguishes itself from sibling tools by noting it is a free 'before purchasing' evaluation, which separates it from likely full-data tools like get_spotter_carrier.

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

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

The description explicitly states when to use the tool: before purchasing a carrier's sighting bundle, and for carrier_identity_verification or cargo_fraud_investigation. It provides clear context but does not mention when not to use it or explicitly name alternative tools, so it stops short of 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?

With no annotations, the description carries the full burden and does well: it discloses exact privacy transforms (faces/persons, non-subject text, burned-in GPS blurred; every plate blurred including the subject truck's own), that payments are time-limited signed URLs, that 95.2% of identity labels are null, and that x_payment is the preferred gasless x402 path. Gaps: URL expiry duration is only called 'time-limited', and no failure behavior (wrong amount, reused tx) is described.

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?

Dense but front-loaded: corpus identity and composition first, then label caveat, then return payload, then payment, then paging. Every sentence carries information an agent needs to call it correctly; the long hex addresses are necessary, not 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?

No output schema exists, so the description must explain returns — and it does (JSONL one row per crop with no plate/geo/timestamp, plus signed image URLs). Pricing, currency, chain, wallet and paging are all specified. Still missing signed-URL lifetime and the actual label fields, which matter for a paid bulk dataset.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds cross-call semantics not present in the schema — that offset paging reuses the same payment_tx rather than paying again, and that the tx must be $50 USDC on chain 8453 to a specific wallet. It also frames the alt-currency path via /.well-known/x402.

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/resource: returns a geo-stripped commercial-truck image corpus (1877 verified truck crops) with labels plus signed crop URLs. It is clearly distinguishable from catalog/bundle siblings, but it never names its closest siblings (get_spotter_cv_sample, get_spotter_cv_profile, get_spotter_carrier) so the boundary is inferred 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?

Gives substantive operational guidance — pay $50 USDC on Base, then page with offset and the same payment_tx, and treat identity labels as a bonus. However, it never says when to pick this full corpus over the sample/profile siblings, so selection against alternatives is left implicit.

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. The description discloses that the tool is 'Free' and specifies the type of information returned (image count, label coverage, de-identification posture). However, it does not explicitly state that it is a read-only operation or describe any limitations or side effects, leaving some ambiguity for an agent unfamiliar with the domain.

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

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

The description is two concise sentences with no redundancy. It front-loads the core purpose ('commercial-truck detection corpus profile') and immediately provides key details (image count, label coverage, de-identification posture) and a usage context. Every word contributes.

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

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

Given the simplicity (0 params, no output schema) and the sibling context, the description adequately covers the tool's purpose and content. It names the specific metrics returned and ties it to a practical scenario (evaluating before purchase). It could be more explicit about the response format, but that is not a major gap for a profile-type 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?

The tool has 0 parameters, so the baseline is 4. The schema fully covers this with an empty properties object, and the description adds value by explaining what the profile contains, which is more useful than any parameter details would be.

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

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

The description clearly states the tool provides a 'commercial-truck detection corpus profile' with specific content: image count, label coverage, and de-identification posture. The use of 'profile' distinguishes it from raw data tools like get_spotter_cv, and the phrase 'before purchasing' ties it to an evaluative purpose.

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

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

The description gives a clear context: 'Free — evaluate the training corpus before purchasing for detection_or_ocr_model_training.' This tells the agent when to use it (when evaluating a corpus prior to purchase). It does not explicitly name alternatives or exclusions, but the context is sufficiently clear for a decision.

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 and does: it discloses de-identification scope (faces/persons, non-subject text, burned-in GPS blurred), that URLs are time-limited signed URLs, the exact payment amount/chain/token/wallet, an alternate Eth/Solana endpoint, and the 4.8% label-availability caveat. This is unusually rich behavioral context for a paid 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?

Front-loads the core purpose and the price/alternative framing before the payment mechanics, and almost every sentence earns its place. It is long and repeats USDC/wallet details already in the schema, which is the main deduction.

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

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

With no output schema and no annotations, the description still specifies the return shape (10 label rows + signed crop URLs), the de-identification guarantees, and the identity-field caveat. An agent has everything needed to call it and interpret the result.

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

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

Schema coverage is 100%, so quote_id, x_payment, and payment_tx are already documented with their own semantics. The description reiterates the payment_tx flow (amount, chain, wallet) but that content is duplicated in the schema, and it adds nothing about quote_id or x_payment beyond the structured fields. 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 and resource — returns a 10-crop trial slice of the geo-stripped commercial-truck detection corpus — and explicitly contrasts it with the full corpus (get_spotter_cv, $50) and the free preview (get_spotter_cv_profile). An agent knows exactly what this returns versus its siblings.

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

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

Gives the condition for use (evaluate crop + de-identification quality before committing to the full corpus) and names both alternatives by name. It also sets expectations on when it is not useful for identity work (usdot/carrier null in the unlabeled majority — judge the images, not the identity fields).

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

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

With no annotations, the description carries the burden. It adds useful behavioral context: the tool is free and serves an evaluation purpose. However, it doesn't disclose read-only nature, output format, or potential limitations, leaving room for more 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 a single, compact sentence that front-loads the tool's purpose and contents, followed by the free attribute and use case. Every word earns its place; no redundancy or fluff.

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

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

The description covers what the profile contains, why to use it (evaluation before purchase), and that it's free. It doesn't detail return structure, but the listed components give a clear picture. No output schema exists, so the description sufficiently covers the tool's essentials.

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

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

Schema coverage is 100% — both 'region' and 'location' have descriptions with examples. The tool description adds no parameter-specific detail beyond what the schema already provides, so the 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?

The description clearly states it returns a monitored location profile with specific contents (assets, feed types, scan interval, term sets). This distinguishes it from sibling tools like get_threat_sample or get_threat_summary, which focus on different aspects.

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 'Free — evaluate coverage and data freshness before purchasing threat assessments' explains the intended use case and why an agent would select this tool. It doesn't explicitly name alternative tools, but the context makes the usage scenario clear.

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

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

With no annotations, the description carries the burden. It discloses that the tool is a free sample, returns live data, and omits flagged items/entities. It also mentions the data proves continuous updates. While it doesn't cover error handling or exact response format, the key behavioral traits and limitations are transparent.

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

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

The description is two sentences plus an example, with every sentence earning its place. It is front-loaded with the core purpose and limitations, and the example usage is practical without extraneous details.

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

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

For a simple sample tool with one optional parameter and no output schema, the description fully covers what is returned, what is excluded, how to upgrade, and how to try it. It is complete for its intended purpose.

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

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

Schema coverage is 100% with a clear description of the location parameter and default. The description adds value by offering a concrete example ('culpeper-town') and instructing how to discover other locations via browse_catalog, going beyond the schema's basic 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 clearly states that this tool returns a free live threat assessment sample with specific data points (threat level, confidence score, event distribution, scan freshness). It distinguishes itself from get_threat_summary by explicitly noting the sample excludes flagged items or entities, and provides upgrade guidance.

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?

Explicit guidance is provided: use this for a free sample to verify data is live, and upgrade to get_threat_summary for full detail. It also gives example usage and directs to browse_catalog for all locations, making the intended context clear and distinguishing from alternatives.

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

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

With no annotations provided, the description carries the full burden and does well: it discloses per-tier pricing ($0.50/$1.00), latency (<200ms), the exact payment chain/token/wallet, and alternative x402 payment paths. It stops short of describing error or failure behavior.

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

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

Front-loaded with purpose and use cases, then tiers, then payment mechanics. It is dense and telegraphic with minimal waste, though the payment details are somewhat compressed into run-on 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?

With no output schema and no annotations, the description must explain returns and it does at a summary level (confidence-scored alerts, event distribution, enriched entities, corroboration scoring). Payment prerequisites and tiers are fully covered, so an agent can proceed correctly.

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

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

Schema coverage is 100%, so the schema already documents all parameters, including tier pricing and payment methods. The description largely restates that (tier costs, 'pass tx hash as payment_tx') rather than adding new meaning, so the 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 resource ('Location threat assessment') and names three concrete use cases (risk_underwriting, facility_security_audit, insurance_risk_modeling). It does not distinguish itself from sibling threat tools (get_threat_profile, get_threat_sample), leaving the agent to infer the difference.

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

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

Gives clear operational context: browse_catalog first, choose tier by cost/detail, and redeem a prior quote via quote_id instead of re-paying. It lacks explicit when-not-to-use guidance relative to the other threat_* siblings.

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

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

With no annotations, the description carries the burden and does well: it discloses exact price ($0.25 USDC), chain, token contract, recipient wallet, and that the payload is limited to 300 frames. It does not state rate limits, whether repeat calls re-charge, or refund behavior, which keeps 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?

The distinguishing facts (trial, size, sibling comparison) are front-loaded before the payment block, and every clause is functional. The long hex addresses make it dense but they are load-bearing payment data, not 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 paid, no-annotation, no-output-schema tool, the description covers what an agent needs to pay correctly and know what data comes back. Minor gaps remain around repeat-call charging and the subject parameter's effect, but nothing blocks 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 coverage is 100%, so the baseline is 3; the description adds value by spelling out the concrete payment amount, chain 8453, and USDC contract for payment_tx, plus an out-of-schema pointer for other chains. It doesn't clarify how `subject` selects skeletons beyond the 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 resource (a 5-second / 300-frame @60fps BVH skeletal sample from the Kimura side-control trial lesson) and explicitly contrasts it with the full-price sibling get_bvh. An agent can distinguish it from get_bvh and the other get_* sample tools 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?

Gives an explicit selection rule: 'use to evaluate data quality before committing,' naming the full $10 get_bvh as the alternative. The trial-vs-paid trade-off is unambiguous, and alternate payment routes (quote redemption, x_payment, Eth/Solana via x402) are pointed to.

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 at all, the description carries the full burden and does so well: it discloses price, chain, token contract, receiving wallet, accepted payment mechanisms, and the supported robot platforms/DOF. Gaps remain around failure/refund behavior, whether a tx hash can be replayed, and rate limits, which matter for a paid 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?

Front-loaded with the sample size, format, and trial-vs-full framing, which is the right priority order. Some material (DOF lists, wallet address, USDC contract) duplicates the schema, making it denser than needed.

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

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

No output schema exists, and the description does characterize the return as a 300-frame 60fps NPZ in the same format as get_robotarget. What's missing is how the file is delivered (base64 payload vs. URL) and the per-robot frame/DOF mapping, which an agent would want before paying.

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

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

Schema coverage is 100%, so robot, subject, quote_id, x_payment, and payment_tx are already fully documented. The description mostly restates the payment_tx route already in the schema and adds only the out-of-band Eth/Solana well-known endpoint note. 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+resource with concrete scope: a 5-second, 300-frame @60fps NPZ robot-trajectory sample from a named lesson. It explicitly distinguishes itself from the sibling get_robotarget by calling itself the cheaper evaluation copy of the same format.

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

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

Gives an explicit when-to-use (evaluate retargeting quality before committing) and names the alternative (full $15 get_robotarget). The trade-off between the trial and the full asset is spelled out, not inferred.

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 mostly succeeds: it discloses the $5 USDC price, chain 8453, exact token and wallet addresses, the 15-minute signed-URL lifetime, and Range support. It omits what happens on unpaid or double-spent calls and whether the tx hash is single-use, so it stops short of full behavioral disclosure.

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

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

Two dense sentences with the resource and the operational constraints front-loaded and no filler. The wallet and token addresses are long but necessary for the payment instructions to be actionable.

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 paid-fetch tool with no annotations, no output schema, and simple flat parameters, the description covers price, chain, token, wallet, URL lifetime, and transport. Remaining gaps (error behavior on invalid view or reused tx hash, and what the URL serves) are secondary but non-trivial.

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

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

Schema coverage is 100%, so the baseline is 3, but the description goes beyond the schema by spelling out the payment flow and pointing to the /.well-known/x402 discovery document for Eth/Solana payers, which is not captured in any parameter. The view/quote_id semantics are left entirely to 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 the resource concretely: multi-view grappling video, 1080p synced cameras, delivered as a signed streaming URL. It implicitly contrasts with motion-capture siblings like get_bvh/get_mocap_sample by naming its intended downstream uses (pose_estimation_training, technique_analysis), though it never explicitly says 'this is the video, not the mocap data'.

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

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

It names two use cases (pose estimation training, technique analysis) and gives the payment path, which implies when to call it. However, there is no guidance on when to prefer a sibling such as get_bvh, get_trial_bvh, or get_mocap_sample, and no exclusion conditions.

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

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

With no annotations, the description carries the full behavioral burden and does so: it verifies the signed token, charges exactly the quoted total, caps discount at 10%, specifies chain/token/recipient addresses, and explicitly guarantees idempotency on repeat calls. That is the mutation, cost, and side-effect profile an agent needs.

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 the outcome, then payment mechanics, then the idempotency guarantee — every sentence carries information. It is dense but slightly overloaded with inline addresses that could be left to 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?

No output schema exists, yet the description explains that the return is a `redeem` list of tools plus arguments including quote_id. Combined with the payment rails and idempotency note, an agent has everything needed to invoke and act on the result.

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

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

Schema coverage is 100%, so the baseline is 3; the description goes further by explaining that `quote` is a signed token enumerating items, prices, discount and total, and by contrasting `x_payment` (gasless EIP-3009 authorization) against `payment_tx` (hash on Base or Solana). It adds real semantics beyond the field text without documenting error behavior for malformed tokens.

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 ('Pay for a negotiated quote') plus the follow-on redemption contract, which no sibling tool covers. An agent can distinguish it from browse_catalog/get_bundle purely from the first sentence.

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?

Clearly frames the two-step flow: pay once here, then call each tool in the returned `redeem` list, and calling again with a paid quote is free. It also directs payment-method choice (x_payment preferred, payment_tx otherwise) but never states the precondition of how a quote is obtained or what to do when no quote exists.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals that the operation returns full lesson detail with pricing and is free, which is useful. However, it does not mention pagination, result limits, sorting, or any potential rate limits, leaving some uncertainty about the full behavior of a search across multiple datasets.

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

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

The description is two concise sentences with the primary purpose front-loaded. The second sentence adds purpose-linked output and pricing information; 'Free' is a useful qualifier. No sentence is wasted, and the structure is easy to scan.

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

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

Since there is no output schema, the description compensates by explicitly stating the return value is 'full lesson detail with pricing.' It omits any mention of result ordering or pagination, which could matter for a broad catalog search, but for a simple 3-parameter search tool with strong schema coverage, the description is largely complete.

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

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

Schema description coverage is 100%, establishing a baseline of 3. The description adds value by mentioning 'techniques' as a match surface beyond the schema's 'labels, path segments, and subject names,' and by tying verticals to dataset types. It enriches the query semantics without needing to restate every 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 opens with a specific verb and resource: 'Full-text search across motion-capture, threat-intel, and rehab-biomechanics datasets.' It also lists match criteria (labels, paths, subject names, techniques) and the return type (full lesson detail with pricing), clearly distinguishing it from sibling retrieval tools like browse_catalog or get_*.

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

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

The description implies usage: use this when you need to search across the catalog and get full lesson detail with pricing to proceed to purchase. It does not explicitly mention when not to use it or name alternatives like browse_catalog for browsing, but the context is clear enough for an agent to select it appropriately.

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