Epsilon

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

Adds real behavior beyond the annotations: this is two-phase (user must approve), it returns an approval link, and the actual cancellation is wallet-signed in the Epsilon app rather than executed immediately. Annotations cover the safety profile (destructiveHint=false, openWorldHint=true), so this extra flow context is the valuable part. Minor gap: no mention of whether the approval link expires.

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 tight sentences with the user-approval requirement front-loaded, followed by the return value and the failure condition. Nothing is padded and nothing redundant is repeated.

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 compensates by stating what is returned ('an approval link'). For a 2-param mutation with full annotation coverage this is close to complete; only the follow-up step after receiving the link is unspecified.

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 both properties are already documented with format (0x-hex, 32 bytes) and length constraint. The description's 'hash from list_orders' merely restates the schema's provenance note, adding no new syntax or 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?

Specific verb+resource ('approve cancelling one of their open orders') with the approval-flow framing stated up front. It is immediately distinguishable from siblings like list_orders (source of the hash) and get_order (read of a single order).

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 prerequisite provenance ('hash from list_orders') and an explicit exclusion ('orders already filled cannot be cancelled'). It stops short of naming what to use instead when an order isn't cancellable, so it's clear but not fully routed.

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

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

Annotations already establish readOnlyHint=true and destructiveHint=false, so safety is covered structurally; the description adds real value by defining the preflight boundary against get_route and disclosing the unit convention. It stops short of describing what a negative result looks like (rejection reason vs. boolean), and the unusual idempotentHint=false on a read-only check goes unexplained.

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 compact sentences, front-loaded with the core purpose, then the routing constraint, then the unit caveat. No filler, and each sentence carries distinct 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 3-parameter, no-output-schema preflight tool, the description covers purpose, timing, sibling boundary and units. The one remaining gap is the shape of the result — whether the agent should expect a pass/fail flag or a structured list of failure reasons — which matters when deciding how to act on the check.

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

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

Schema description coverage is 100%, so all three parameters are already documented in the schema, including the RAW-units note on amountIn. The description's 'Amounts are RAW token units' repeats rather than extends that, 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 (check) and a precisely scoped resource (a resting order — limit, stop, DCA, trailing — for a pair and size) and enumerates exactly what is validated: oracle support, liquidity, minimum size. It also explicitly differentiates itself from get_route, so an agent can tell the two apart without opening either 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 trigger ('Run this before signing any resting order') and names the alternative with its exclusion ('it does not price the trade — get_route does'). This is the when-to-use, when-not-to-use and alternative all in one sentence.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered; the description adds real behavioral context beyond them — link lifetime of 30 minutes, the pending-vs-submitted distinction with hash presence, and an explicit polling throttle. It does not cover auth requirements or what happens to an approval after the link expires.

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

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

A single dense sentence front-loads the core purpose (status of an approval) before the status enumeration and the get_order handoff. Every clause carries information, though the parenthetical status list makes it slightly harder to scan than a short lede plus a follow-up sentence would be.

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 compensates by spelling out the possible return states and the correct next tool for each, which is the key information an agent needs. Missing only peripheral items such as auth/permission requirements and post-expiry behavior.

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?

Only one parameter and schema description coverage is 100%, so the schema already documents that `id` is the apr_… value returned by place_*/cancel_order. The description adds no syntax, format, or edge-case semantics beyond that, so the baseline 3 is appropriate.

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

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

States a specific verb+resource ('Status of an approval you created') and enumerates the full set of possible outcomes (pending, submitted, rejected, failed, expired). It also routes the agent to the sibling get_order once an orderHash/txHash exists, so it is distinguishable from check_order and get_order without opening a 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 explicit follow-up routing ('then use get_order to follow fills') and a polling cadence constraint ('Poll no more than every few seconds'), which tells the agent how to behave after calling. It stops short of stating when this tool should not be used or which sibling to prefer when the approval is already submitted/failed.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds real value beyond that by stating the catalog is machine-readable and that entries include meanings and retry guidance, i.e., it discloses what the agent gets back and how to act on it.

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

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

Two tight sentences: the first defines the resource and its contents, the second gives the usage trigger. Front-loaded, no filler, every clause earns its place.

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

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

With no output schema, no parameters, and safety already carried by annotations, the description still explains the return content (error codes with meanings and retry guidance) and when to call it. Nothing an agent needs in order to invoke it correctly 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?

The tool takes zero parameters, so the baseline is 4; there is no parameter surface for the description to clarify or for the schema to omit. Nothing more is needed here.

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

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

The description states a specific resource (a catalog of every Epsilon API error code) and what it contains (meanings and retry guidance). No sibling tool does anything similar, so an agent can distinguish it instantly from check_order, get_quote, search_docs, 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 gives an explicit trigger: consult it whenever another tool returns an error code you must interpret or decide whether to retry. That is clear when-to-use guidance; the only thing absent is a when-not-to-use clause, which is largely moot since no alternative error-lookup tool 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the useful 'No API key required' context and clarifies the return payload is full source code, but does not mention potential size, formatting, or rate-limit concerns. Reasonable value added beyond annotations.

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

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

Two concise, information-dense sentences with zero fluff. The main purpose is front-loaded, and the auth note earns its place. There is no redundancy with the schema or annotations.

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

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

For a simple single-parameter read tool with full schema coverage and safety annotations, the description is nearly complete: it says what is returned, where the id comes from, and that no auth is needed. The only minor gap is that the return format (raw text vs. JSON) is not specified, but this is not critical for invoking the tool correctly.

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

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

Schema description coverage is 100%, and the single 'id' parameter is well-documented in the schema with a concrete example. The description does not add parameter-level details beyond pointing to list_examples as the id source, which is the expected baseline since the schema already provides full semantics.

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

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

States a specific verb ('get'), resource ('full source code of one Epsilon integration example'), and scope ('by id from list_examples'). It clearly distinguishes itself from list_examples (which lists examples) and other sibling tools, so an agent knows exactly what it returns.

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

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

The description identifies the source of the id ('by id from list_examples') and notes that no API key is required, giving clear conditions for use. It does not explicitly name alternatives or when-not-to-use, but the 'from list_examples' pointer effectively routes the agent to obtain the correct id.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, so the safety profile is covered. The description adds real value beyond them: grant lifecycle is user-managed in-app, and the call predicts immediate placement vs. approval-link flow. The only omission is that idempotentHint=false is unexplained for what reads like a pure read.

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

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

Two sentences, front-loaded with what the tool returns and then the reason to call it. The first sentence is a long field list, but every item is meaningful payload disclosure in the absence of an output schema. Little waste overall.

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 takes on the job of explaining return values and does so thoroughly (wallet, caps, remaining today, order kinds, signer status). Combined with the usage trigger, 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?

Zero parameters, so the schema carries no semantic burden and the baseline is 4. The description adds no parameter detail because none is needed, though it does imply the channel context is derived from the session rather than passed in.

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 ('the signed-in account's agent grant for this channel') and then enumerates exactly what the grant object contains (wallet, per-order and daily caps, remaining today, allowed order kinds, signer status). This is unmistakably distinct from the sibling get_me, get_approval, and the place_* 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?

Gives explicit timing ('Call it before placing') plus the decision it enables (whether an order will be placed immediately or need an approval link), and names get_approval implicitly by referencing the approval path. It also clarifies the alternative to mutation: grants are created and revoked by the user in the app, never by a tool.

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

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

Annotations declare readOnlyHint=true, idempotentHint=false, and destructiveHint=false, so the safety profile is covered. The description adds useful context about the scope-dependent response contents but doesn't mention rate limits, authentication requirements, or data freshness beyond the window. With annotations covering safety, the added scope behavior is adequate but not rich.

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

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

Front-loads the primary recommendation (scope=overview) and the routing to alternatives in three tightly packed sentences. Every sentence earns its place by clarifying scope outputs or directing to siblings.

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 absence of an output schema, the description is thorough in explaining what each scope returns. However, it lacks details on the shape of the returned data (e.g., field names, pagination) and specific behavioral traits like required permissions. For a read-only market stats tool, this is nearly complete but leaves minor gaps.

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

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

Schema coverage is 100%, so the schema already documents both the scope and window parameters. The description's parameter details largely reiterate the schema definitions (e.g., scope=volume returns per-token and total swap volume over window). It adds marginal value over the structured fields.

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

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

States the specific resource (market-level numbers for Epsilon on Robinhood Chain DEX) and uses a precise verb. It distinguishes itself from siblings by naming search_tokens and list_fills as alternatives for narrower needs.

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 recommends scope=overview as the best first call, then details what each scope returns and routes to search_tokens and list_fills for other needs. It provides clear when-to-use and when-not-to-use guidance.

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

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

Annotations only cover read-only/non-destructive semantics; the description adds the real behavioral context: it requires an OAuth session, behaves differently on the keyless endpoint, and orders linked wallets with embedded ones first. The auth prerequisite and endpoint-specific fallback are exactly the traits annotations cannot 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?

Front-loaded with what the tool returns, then the usage directive, then the auth caveat. It is dense and packed into essentially two long sentences with colons, which is efficient but slightly run-on compared with the cleanest definitions.

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 only read-only annotations, the description carries the return-value burden itself and does so by enumerating the fields returned and their ordering. Auth requirements and the keyless-endpoint fallback round out everything an agent needs to call it correctly.

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

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

The tool takes zero parameters, so the baseline is 4 and there is no input schema to compensate for. The description's field list pertains to outputs rather than inputs, which is acceptable given the empty schema.

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

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

Names a specific verb/resource (retrieve the signed-in Epsilon account behind this session) and enumerates exactly what it returns: account id, handle, linked wallets, granted scopes, and connected client. This is clearly distinguishable from siblings like get_order, get_quote, or search_tokens, which deal with market data rather than session identity.

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 states when to call it ('Call it first after sign-in to learn the wallet address other tools need'), which makes it a prerequisite for other tool calls. It also documents the precondition (an OAuth session via /mcp/account) and the behavior on the keyless /mcp endpoint, where it explains how to sign in instead.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds the return payload (status, parameters, fills) and the status lifecycle values, which implicitly explains the non-idempotent annotation (status evolves). It stops short of describing freshness or rate limits, but adds real value beyond the annotations.

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

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

Two sentences, zero filler, and the core purpose leads before the sibling routing. Every clause earns its place by either defining the return or preventing a wrong-tool call.

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 must carry the return contract, and it does: status with its enum, parameters, and fills. Combined with the routing guidance, nothing an agent needs to call this correctly 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?

There is one parameter and schema coverage is 100% – the schema already spells out 'EIP-712 order hash (0x-hex, 32 bytes)'. The description only says 'by hash' and adds no format, casing, or lookup semantics beyond that, so it neither helps nor hurts relative to 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?

States a specific verb and resource ('One Epsilon order by hash') and enumerates what comes back: status, parameters, and fills. The status enum values (pending/active/filled/cancelled/expired) pin down the resource precisely, and the description explicitly distinguishes itself from list_orders and get_orderbook.

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 explicit routing: use list_orders first to find an order by wallet, and use get_orderbook for a pair's resting orders. Both alternatives come with the condition that selects them, so an agent knows exactly when this tool is the right call.

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 cover the safety profile (readOnlyHint=true, destructiveHint=false), and the description adds real context beyond them: the book reflects live pending/active state (which explains the idempotentHint=false), covers both sides, and is sorted largest first. It does not mention depth limits, truncation, or whether the result is a snapshot, 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?

Two sentences, zero filler, with the core purpose front-loaded and the sibling routing clause placed last where it belongs. Every clause earns its place.

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

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

There is no output schema, and the description partially compensates by describing the return shape (both sides, largest first). What is missing is any hint about result size, depth limits, or pagination for a market-wide book, which an agent would need to consume the response safely.

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

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

Schema description coverage is 100%, so tokenA/tokenB formats are already documented. The description adds the semantic frame that the two tokens form a pair whose both sides are returned, but no additional format, ordering, or constraint detail beyond the schema. 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?

Names a specific resource (the market's open limit orders for a token pair), the scope (both sides, pending/active, largest first), and the practical meaning ('liquidity you can rest against'). It also explicitly distinguishes itself from the sibling list_orders, so an agent can route without opening either 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?

States the selecting condition and the alternative by name: 'For one wallet's own orders use list_orders instead.' That is an explicit when-not paired with a named sibling, leaving nothing to inference.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description reinforces this with 'Never executes' while adding a non-obvious caveat about raw units. It does not explain why idempotentHint=false (quote freshness/slippage), which would be the one remaining behavioral gap.

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

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

Three tightly packed sentences with the core purpose front-loaded and no filler. Slightly dense but every clause carries routing, unit, or safety 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 3-param read tool with no output schema, the description names what comes back (expected output and price) and routes to the richer sibling. The exact response shape/decimals of the output is left implicit, a minor gap given no output schema exists.

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 tokenIn/tokenOut/amountIn are already fully documented, including the RAW-units note on amountIn. The description restates the raw-units requirement but adds no syntax or format detail beyond the schema; 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 ('Best executable quote for swapping tokenIn → tokenOut') with the chain context (Epsilon, Robinhood Chain id 4663) and the returned values (expected output and price). It explicitly distinguishes itself from the sibling get_route.

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 ('quick price check') and when-to-use-the-alternative ('use get_route when you need the venue split, fee legs or minimum output for an order you will sign'). The selection criterion is fully specified.

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/destructiveHint=false, and the description reinforces 'Read-only'. It adds genuinely useful behavior beyond the annotations: that orderType must be passed for a resting order so the correct fee cell is served, that feeLegs are what a signed order must embed, and that amounts are RAW token units. It does not explain the idempotentHint=false asymmetry or any rate limits.

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

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

Front-loads the payload contents, then routes to alternatives, then states read-only and unit conventions. Every clause carries information; 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 compensates by naming the returned fields (venue split, expected/minimum output, price impact ppm, feeLegs) and the unit convention. For a 7-parameter routing tool it is nearly complete; only the idempotency flag and response shape specifics are left to inference.

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

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

Schema description coverage is 100%, so every parameter including wallet, orderType, triggered and slippageBps is already documented in the schema. The description restates the orderType/fee-cell dependency and the RAW-unit convention rather than adding new syntax or format detail, which lands at the baseline for full schema coverage.

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

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

States a specific verb (get) and resource (route) and enumerates exactly what the breakdown contains: venue split, expected/minimum output, price impact in ppm, and feeLegs. It explicitly contrasts with get_quote ('plain price') and check_order, so an agent can distinguish it from siblings without opening schemas.

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

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

Names two alternatives with the condition that selects each: get_quote for a plain price, check_order for executability of a resting order. It also states when to pass orderType (resting order) versus omit it (direct swap), covering both when-to-use and when-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 already declare readOnlyHint=true and destructiveHint=false, and the description adds useful context beyond those: it is a non-authenticated operation ('No API key required'). It does not describe the return shape, but for a simple listing tool the key safety and access behaviors are covered.

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

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

Two short sentences deliver the purpose, scope, sibling routing, and auth requirement with no wasted words. The main action is front-loaded and every clause earns its place.

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

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

For a zero-parameter, read-only listing tool with an explicitly named sibling for source retrieval, the description is complete. The agent has enough information to decide when to call it and what to expect at a high level.

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

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

The tool has zero parameters and schema coverage is 100%, so there is no parameter burden for the description to carry. The baseline for zero-parameter tools is 4, and the description appropriately avoids inventing unnecessary parameter details.

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

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

The description clearly states a specific action ('List') and a specific resource ('runnable Epsilon integration examples'), and it enumerates the exact kinds of examples included. It also explicitly directs the agent to get_example for the full source, which differentiates this tool from its closest sibling.

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

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

The description is explicit that this tool is for listing examples, and it names the alternative tool (get_example) to use when fetching full source. It also notes that no API key is required, giving the agent a clear prerequisite signal.

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 cover the safety profile (readOnlyHint=true, destructiveHint=false), so the bar is lower. The description nevertheless adds two non-obvious behaviors: results are ordered newest-first and amounts are RAW token units — the latter is a critical caveat absent from the schema.

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

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

Two tight sentences with the resource and ordering front-loaded, the sibling disambiguation next, and the raw-units warning last. No filler; the em-dash apposition is minor.

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 describing the return set (executed swaps/fills, newest first, raw units), which it does adequately. Pagination behavior beyond the limit cap is the only thin spot, and the schema covers that.

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 both parameters (limit with default/cap, wallet filter) are fully documented there. The description only restates the optional wallet filter and adds no syntax or unit detail per parameter, 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 precise verb+resource ('Executed trades ... the trade history') and immediately scopes it against the sibling list_orders, which handles resting/open orders. An agent can pick between the two without opening either 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?

Explicitly routes the agent: use this tool for filled/executed trades, use list_orders for resting/open orders. It also notes the wallet filter is optional, so the default (all wallets) is inferable.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds genuinely new behavioral context — that results are the portfolio view sorted newest-first — which the annotations and schema do not convey. It stops short of describing pagination behavior or result size, keeping it below a 5.

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

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

Two sentences, zero filler, with the primary purpose and ordering stated before the sibling routing guidance. Every clause earns its place.

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

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

For a read-only list tool with all four parameters documented and annotations covering safety, the description is essentially complete; no output schema means return-value detail is not required. A minor gap remains around pagination/cursor behavior beyond the schema's limit cap, which keeps it from a 5.

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

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

Schema description coverage is 100%, so all four parameters (type, status, limit, wallet) are already documented in the schema. The description only restates the status/type filtering that the schema covers, adding no format, default, or constraint detail beyond it. 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 (list a wallet's Epsilon orders) plus the scoping dimensions (status/type filters) and the ordering ('portfolio view, newest first'). It also explicitly distinguishes itself from get_order and list_fills, so an agent can select it without opening any 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?

Names both relevant alternatives and the condition that selects each: get_order for a single order's fills, list_fills for executed trades. That is explicit when-to-use routing rather than implied context.

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

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

Annotations already declare destructiveHint=false, openWorldHint=true, and non-idempotency, but the description adds material behavior an agent cannot infer: execution is keeper-driven after signing, the tool always returns an approval link, and DCA is never executed under an agent grant, so user consent is mandatory. That is exactly the kind of context annotations cannot carry.

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 tight sentences, front-loaded with the core action and slices, then the optional gate, then the execution/approval behavior. No filler or restated boilerplate.

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

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

For a 9-parameter mutation tool with no output schema, the description covers the approval flow, the return value (an approval link), and execution semantics. Combined with full schema coverage and annotations, an agent has everything needed to invoke it correctly.

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

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

Schema description coverage is 100%, so every parameter (including `amount`, `executions`, `triggerPrice`, `pauseOnRecovery`) is already documented in the schema. The description reinforces that amount is the TOTAL in human units, but that duplicates the schema text rather than adding new meaning; baseline 3 is appropriate.

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

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

The description gives a specific verb+resource (place a DCA program), states the exact mechanic (sell amount of tokenIn for tokenOut in `executions` equal slices, one every `every`), and adds an optional triggerPrice gate. This clearly separates it from the sibling order tools (place_limit_order, place_market_order, place_stop_order), which are single-execution orders, not recurring sliced programs.

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 context: this is for a sliced DCA program, optionally gated by a price threshold, requiring user approval before anything happens. It does not, however, explicitly state when to prefer DCA over place_market_order or place_limit_order, so the routing decision is left partly to inference.

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

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

Annotations establish this is a non-read-only, open-world, non-idempotent write, but the description adds substantial context beyond them: keeper-executed persistence with the chat closed, the two possible outcomes (queued with stable requestId under status reserved/submitted, or needs_approval with an approval link signed in the Epsilon app), and the grant/cap condition determining which. This is exactly the behavioral detail annotations cannot carry.

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: the core action and price semantics come first, then execution paths and status values, then sibling routing. Nearly every clause carries actionable information (keeper execution, requestId stability, HUMAN units) with 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 an 8-parameter mutation tool with no output schema, the description covers the outcomes an agent needs to interpret (status reserved/submitted vs needs_approval), the prerequisite check_order call, and the routing alternatives. Nothing essential for correct invocation is left implicit.

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 nonetheless reinforces two semantics that matter for correctness: amounts are in HUMAN units and limitPrice is expressed as tokenOut per tokenIn with an 'or better' fill direction, plus the stable requestId retry behavior. It adds value on top of the schema without fully restating it.

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 ('place a resting limit order') and defines the trigger condition precisely (sell tokenIn for tokenOut once market reaches limitPrice or better). It explicitly distinguishes itself from the sibling order types place_stop_order and place_market_order, so an agent can route without opening schemas.

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

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

Gives explicit routing rules: use place_stop_order for a protective sell below market, place_market_order for an immediate swap. It also states the prerequisite 'Run check_order first' and explains the two execution paths (agent grant within caps vs approval link), covering when the tool succeeds autonomously and when it will not.

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 real context beyond the annotations: this does not fill, it returns an approval link and the user signs in the Epsilon app. That is critical behavioral knowledge an agent could not infer from readOnlyHint=false / openWorldHint=true. It stops short of covering approval-link lifetime, non-idempotency (annotations say idempotentHint=false but the description doesn't warn that retries create duplicate requests), or fund/slippage exposure.

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?

Four short sentences, each carrying distinct load: action, return semantics, prerequisite, alternative. The non-fill caveat is front-loaded right after the action, which is exactly where an agent needs it.

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 compensates by explaining what actually comes back (an approval link) and who completes the flow (the user in the Epsilon app). Combined with the get_quote prerequisite and sibling routing, an agent has everything needed to call this correctly.

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

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

Schema description coverage is 100%, including the 'HUMAN units' note for amount, so the description's 'Amounts are HUMAN units' restates the schema rather than adding to it. None of the five parameters (note, slippageBps, token addresses) get supplemental meaning in the prose. 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 ('place a market swap of amount tokenIn → tokenOut') with the execution venue ('best current route'), and explicitly contrasts itself with the price-conditional siblings. An agent can distinguish this from place_limit_order/place_stop_order without opening any 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 prerequisite ('Use get_quote first to tell the user what to expect') and an explicit routing rule away from the tool ('For a price-conditional order use place_limit_order or place_stop_order'). When-to-use and when-not are both covered.

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 cover safety flags (readOnlyHint=false, destructiveHint=false, idempotentHint=false, openWorldHint=true); the description goes well beyond them by disclosing that execution is keeper-driven, that orders queue under an agent grant or fall back to an approval flow, and that autonomous stops enforce a signed minimum and may remain unfilled after a price gap. Those are exactly the behavioral traits an agent cannot infer from structured fields.

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

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

Roughly five short sentences, front-loaded with the core action and trigger semantics before routing, grant, and gap-fill caveats. No sentence is redundant: each adds routing, execution, or constraint 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?

There is no output schema, so the description carries the return-shape burden and does so — it tells the agent the outcome is either a queued order under a grant or an approval link with status needs_approval. Combined with grant prerequisites, keeper execution, and gap risk, nothing material for correct invocation is missing.

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

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

Schema description coverage is 100%, so the baseline is 3, and the description earns an increment by fixing the unit convention ('HUMAN units') and restating the triggerPrice quote direction (tokenOut per 1 tokenIn) plus its strict-floor behavior. It does not add detail on slippageBps, requestId, or note beyond what the schema already documents.

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 ('Place a stop-loss') and immediately defines the trigger semantics ('sell amount tokenIn for tokenOut if the price falls to triggerPrice, quoted tokenOut per tokenIn'). It explicitly distinguishes itself from the closest sibling, place_limit_order, so an agent can route without opening either 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 when-to-use rule keyed to market direction: use place_limit_order to sell ABOVE the market (take profit), this tool for protection BELOW it. It also states the precondition path (must be covered by an active agent grant) and the fallback (returns an approval link with status needs_approval) when it is not.

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 meaningfully beyond annotations: keeper execution after signing, the fact that it always returns an approval link, and the agent-grant prohibition. These are real operational constraints the annotations (readOnly=false, openWorld=true, idempotent=false) do not convey. Lacks detail on what happens if the user rejects the approval or whether placement can be cancelled later.

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 tight sentences, front-loaded with trigger semantics before the alternative and the approval-link caveat. Every clause adds decision-relevant information, with no restatement of the tool name 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?

No output schema exists, and the description compensates by stating the tool always returns an approval link. Combined with the agent-grant caveat and sibling routing, an agent has enough to place the order correctly; only post-approval lifecycle details are absent.

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 all seven parameters are already documented in the schema; the description only reinforces the 'HUMAN units' convention and restates the trailPercent meaning. Baseline 3 is appropriate since the schema carries the parameter burden.

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 (place) and resource (trailing order), then defines the trigger semantics precisely: sell tokenIn for tokenOut when price drops trailPercent below its running high. It also names the sibling it is not (place_stop_order for a fixed level), so the agent can route correctly without opening either 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?

Explicitly routes fixed-level stops to place_stop_order and states a clear limitation: trailing stops are never executed under an agent grant. What is missing is the inverse condition — no guidance on when a trailing stop is preferred over limit/market/DCA siblings beyond the single alternative named.

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

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

Annotations already signal readOnly/destructive, and the description adds the useful auth fact 'No API key required' plus the documentation scope. It does not cover rate limits or result format details, but for a non-destructive search tool the annotations lower the burden.

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

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

One sentence states the action, resource, scope, result, and auth requirement with no filler. It is front-loaded and every clause is informative.

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 two-parameter, read-only search tool this is complete enough: an agent knows what to search, what it will get back, and that no auth is needed. A return-format example or result schema would push it to 5, but none is required by the tool's simplicity.

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

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

Schema coverage is 100%: the query parameter has an example and the limit parameter documents default/cap. The description adds no further parameter-level detail, so the baseline of 3 applies.

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

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

The description opens with a specific verb and resource: 'Search the Epsilon developer documentation' and lists the covered topic areas. It also states the return behavior ('Returns the most relevant doc sections'), which clearly separates it from the data/order sibling tools.

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

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

The description makes the tool's context clear: it is for looking up Epsilon API/auth/signing/webhook documentation rather than for market data or order operations. It does not explicitly name alternative tools or exclusion criteria, so it stops short of 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 already declare readOnlyHint=true and destructiveHint=false, so no contradiction exists. The description adds useful behavioral context: it returns address and decimals, supports address lookup as well as symbol/name fragments, and clarifies how to disambiguate results using volume30dUsd. It does not describe the full response structure, but the annotations cover the safety profile.

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

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

The description is two tight sentences with no filler. The primary purpose is front-loaded, the usage directive follows immediately, and the disambiguation tip earns its place by addressing a real practical issue.

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

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

For a low-complexity 2-parameter tool with read-only annotations, the description is largely complete: it explains the core function, the call-first workflow, and the disambiguation cue. There is no output schema, so a bit more return-shape detail could help, but the essentials for correct invocation are present.

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

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

Schema description coverage is 100%, so both parameters are already fully documented in the input schema. The description adds tool-level context around the lookup concept and the volume30dUsd output field, but it does not significantly expand on the input parameters themselves. The baseline of 3 applies because the schema carries the parameter documentation burden.

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

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

The description states a specific verb ('Resolve a token symbol or name to its address and decimals') and distinguishes the tool from all siblings by noting that every other tool takes addresses. It also mentions the disambiguating volume30dUsd field, making the tool's role 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 when-to-use guidance: 'call this FIRST when the user names a token; every other tool takes addresses.' It also explains how to handle same-symbol ambiguity by checking volume30dUsd, which is concrete and actionable.

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