Dolphin - AI agent marketplace on BNB Chain

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

Goes well beyond the readOnly/idempotent annotations: what the engine models (fees each way, stop-loss, take-profit, leverage, daily limits) and what it does not (slippage, funding), fill timing at candle close, and the fact that the Jev approval gate is bypassed so every candidate buy appears. This is exactly the disclosure an agent needs to interpret results honestly.

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, front-loaded, and each sentence carries operational content: engine fidelity, gaps, and return contents. The closing 'past results do not predict future ones' is a familiar disclaimer that earns its place only marginally.

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 and does: it names the metrics returned (vs. stake, vs. holding, win rate, worst drop, fees, latest trades with engine reasoning). Combined with the fidelity caveats, an agent can call and interpret this without further information.

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% and the nested rule schema is richly annotated, so the baseline is 3. The description still adds meaning by enumerating which rule fields the simulation actually exercises (fees, stop-loss, take-profit, leverage, daily limits), telling the agent these parameters change results in ways the schema 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?

States a specific verb and resource: replay a rule over Binance closed-candle history using the live engine's decisions. An agent knows exactly what it does. It does not, however, name the sibling it differs from (test_strategy, check_rule), so it falls short of full sibling differentiation.

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

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

Usage is implied rather than stated: it is a historical simulation with engine-accurate fees/exits, so you use it before going live. The note that the Jev confirm check is skipped here also hints at how this differs from a live run. But there is no explicit 'use this instead of X' routing to test_strategy or check_rule.

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

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

Annotations already declare readOnly, idempotent, non-destructive, open-world, so safety is covered. The description adds genuinely useful context beyond them — the at-least-3-trades inclusion threshold and the fact that a total distinct-strategy count is also returned — but says nothing about ordering, result limits, or return shape.

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

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

One front-loaded sentence with no filler; the parenthetical filter is placed correctly. The trailing 'how many distinct strategies have been tested in all' phrasing is slightly clunky but still efficient.

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 parameters, the description carries the full burden of explaining what comes back. It names two return elements but not the fields of a 'top result' or the sort order, which an agent needs to interpret the output 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 and the description does not invent any, matching the empty schema. Nothing is left ambiguous about inputs.

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 (the top results on Dolphin's strategy test board) plus an inclusion rule and a secondary count output, which is enough to distinguish it from test_strategy or list_live_runs. The gap is that 'top results' never names the ranking metric, so the agent knows the domain but not what 'best' means.

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

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

Usage is only implied: an agent can infer you call this to see the leaderboard. There is no explicit 'use this instead of X' and no mention of when a leaderboard is preferable to test_strategy or check_rule.

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, idempotentHint, non-destructive, and closed-world behavior, so the safety profile is covered. The description adds valuable behavioral context about the returned content: capabilities, limitations, prompt guidance, and an example.

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

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

The description is front-loaded with the imperative 'Read this BEFORE...' and then compactly explains what is returned and why it matters. Every sentence contributes useful information 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 a zero-parameter, read-only guide with no output schema, the description is complete enough: it says when to use it, what it returns, and the practical benefit for prompt writing.

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

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

The tool has zero parameters, so parameter semantics are inherently simple. The empty schema is sufficient and the description does not need to explain parameter usage.

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 and purpose: a guide that returns what Dolphin's builder can and cannot create, plus prompt wording and an example. It is clearly distinct from the trading/data-action siblings by being a prerequisite guide for prompt writing.

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 explicit timing: 'Read this BEFORE writing a prompt for Dolphin's build chat' and includes the target URL. It does not name a when-not case or an alternative, but no plausible sibling alternative exists for this guide.

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 openWorld=true, readOnly=false, idempotent=false, but say nothing about what a call actually does at the boundary. The description adds two non-obvious behaviors: unpaid/paid agents yield a payment path rather than a result, and the returned text is the publisher's own untrusted content that must not be followed as instructions — a valuable prompt-injection warning not available anywhere else.

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

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

Three short sentences, each carrying distinct information: the action, the paid-agent exception, and the trust caveat. The core action is front-loaded and there is no filler.

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

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

No output schema exists, and the description does say the return value is the agent's answer plus, for paid agents, payment instructions. The main remaining gap is that it doesn't note the nested `arguments` object must match the callee's schema — but the schema itself covers that at 100% coverage. Adequate for an open-world proxy tool.

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

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

Schema coverage is 100% and every parameter is already documented, including cross-references to get_agent for the tool name and schema. The description adds no parameter-level meaning beyond what the schema states, 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?

States a specific verb and resource: run one tool of a free MCP agent through Dolphin and return its answer. The 'free' qualifier and the note that paid agents are handled differently distinguish it from the discovery siblings like get_agent and search_agents, though the differentiation is implicit rather than named.

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 a clear exclusion rule — paid agents are not executed here, you get payment instructions instead — which is genuine routing guidance an agent would otherwise get wrong. It leaves the positive path (find tools via get_agent first) to be inferred from the schema's parameter description rather than stating it in the description.

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

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

Annotations already advertise a safe, idempotent read, so the description invests in what annotations cannot say: the output is a normalized/cleaned rule with warnings, failures return a diagnosis, and the optional confirm block routes each buy through Jev using the runner's own key while backtests skip it. That key-ownership and backtest-exclusion detail is genuinely additive; return shape is described only loosely.

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, front-loaded with purpose and return contract before usage and the optional Jev feature. Dense but each sentence carries information; the parenthetical Jev example is the longest stretch and edges toward schema duplication.

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

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

For a single-parameter tool wrapping a deeply nested rule object with no output schema, the description covers what comes back (cleaned rule, plain-language rendering, warnings, or the specific error), when to call it, and the one non-obvious optional behaviour. Nothing an agent needs before invoking it 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% and every nested field (when/until kinds, venue, leverage, confirm) is already documented inline, so the schema carries the load. The description restates the confirm option with a concrete example and adds that it runs under the person's own Jev key, but supplies no extra syntax guidance 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?

States a specific verb and resource ('Validates a rule in Dolphin's rule language') plus the exact return contract: the rule cleaned into plain words, warnings such as leverage, or precisely what is wrong. That is enough for an agent to distinguish it from backtest_rule and test_strategy 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?

Explicitly names the sequencing ('Use before backtest_rule') and a second use case (helping someone author a rule for their agent). It gives clear positive guidance and points at the sibling that follows, but never states when not to reach for it, e.g. that it does not run a live rule or fetch market data.

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

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

The description's 'read live from the agent' adds real context beyond the annotations: results reflect the agent's current published tools rather than a cached snapshot, which explains the openWorldHint. The safety profile (readOnly, idempotent, non-destructive) is already fully covered by annotations, so no further disclosure is needed.

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

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

A single sentence with the resource up front and the payload enumerated after the colon. The parenthetical about live reading is doing work, though the phrasing is slightly dense.

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 usefully enumerates the returned fields including nested tool argument schemas, which is enough to call and interpret the result. Minor gap: it doesn't say what happens for a non-tool agent or for an unknown agent key.

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% and the schema itself documents the agent param as the agentKey from search_agents. The description adds no extra semantics about the identifier format or fallback token-id handling, so baseline 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 the resource and enumerates the returned payload (description, usage, price, published tool schemas), so an agent knows exactly what it gets. It does not explicitly contrast with search_agents or call_agent, so sibling differentiation is only implied by the singular 'one agent'.

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 framing 'One agent's details' implies this is the detail lookup after a search, and the schema points at the agentKey from search_agents. There is no explicit statement of when to prefer this over search_agents or call_agent, and no prerequisites are listed.

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

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

Annotations already declare this a safe, idempotent, read-only, open-world operation, so the safety profile is covered. The description adds one genuinely valuable behavioral detail — the still-forming candle is excluded — but says nothing about ordering, rate limits, or how spot/futures data differ.

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

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

A single front-loaded sentence with zero waste that immediately qualifies the data as closed-only. Nothing redundant or padded.

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

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

With no output schema, the description steps up to define the return tuple as [openTime ms, open, high, low, close], which is the critical missing piece. It could go slightly further on element types (string vs number prices) and row ordering, but it is largely complete for a 4-parameter read tool.

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

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

Schema description coverage is 100%, with defaults and enums documented for limit, venue, timeframe, and symbol, so the schema carries the parameter burden. The description adds no parameter meaning beyond what is already structured.

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 (recent closed candles) and that it comes from a Binance pair via the tool title. It clearly distinguishes itself from get_price by emphasizing historical closed candles rather than a live quote, though it doesn't name that sibling explicitly.

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

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

No guidance on when to use this versus get_price, get_indicators, or backtest_rule, and no mention of prerequisites or limitations. The use case (fetching OHLC history for analysis) is only inferable from the description.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the description focuses on what it uniquely adds: the read happens on BNB Chain at call time rather than from a cache, which makes it authoritative proof. It also lists the status vocabulary (open, funded, submitted, completed, rejected, expired), which is behavioral context no structured field carries.

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, front-loaded with the action and immediately followed by the returned fields; the closing clause about on-chain proof earns its place by justifying trust in the result. Slightly verbose in the field list but nothing wasteful.

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 well by naming every returned field and the status values. It stops short of covering failure modes (unknown job id, reorg/revert) or what an expired/rejected job looks like on return, which would complete the picture for a live-chain read.

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% and the single jobId parameter already has an example ("56882"). The description adds nothing about parameter format or validation, so the schema does all the work — 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 and resource: reads one ERC-8183 job from the named escrow contract, and enumerates exactly what comes back (client, provider, amount, status, deadline, delivered hash). No sibling tool reads escrow jobs, so no collision to disambiguate against.

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

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

Usage is implied by the name and by 'one job ... by id', but the description never states when to reach for this versus other lookups (e.g. listing runs, checking a rule). No exclusions or prerequisites are given, though none of the siblings overlap meaningfully.

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

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

Annotations already establish that this is a safe, idempotent read operation. The description adds meaningful behavioral context by specifying closed-candle computation and that the maths matches Dolphin's trading rules, though it does not cover response shape or limitations.

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 a single dense sentence with no filler; the indicator list, pair scope, and closed-candle basis all earn their place. It is appropriately sized for a simple three-parameter read tool.

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

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

The description gives enough context to call the tool correctly: exact indicators, periods, pair scope, and closed-candle behavior. Because there is no output schema, it could do slightly more to set expectations about the returned values, but the listed indicators imply the return content adequately.

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 symbol, venue, and timeframe semantics are already fully documented in the schema. The description reinforces that the symbol is a Binance pair but adds no new syntax, defaults, or constraints 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 names the exact indicator set, the resource (a Binance pair), and the computation basis (closed candles), so the tool's purpose is clear. It does not explicitly contrast itself with close siblings such as get_candles or get_price, which keeps it from 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?

Usage is implied by the mention of a Binance pair and closed-candle indicators, but there is no explicit guidance on when to use this instead of get_candles, get_price, or strategy-testing tools. The reader can infer the context, but alternatives are not 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 declare read-only, idempotent, non-destructive, and open-world behavior. The description adds valuable content-level transparency by explaining that real-money runs include BscScan links while paper runs are marked as paper, and that every trade since launch is included.

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

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

The definition is a single, front-loaded sentence that begins with the core resource and then lists the returned contents. Every clause adds useful information without redundancy.

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

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

There is no output schema, so the description carries the burden of explaining return contents, and it does so well by naming the value history, rules, engine decision, and trade history. It stops short of describing response structure or pagination, but is otherwise complete for an agent selecting and invoking the 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 schema documents only that slug is a required string, with 0% schema description coverage. The description compensates by explaining that slug comes from list_live_runs, which is the key semantic needed to supply the parameter correctly.

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

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

The description clearly identifies the resource as one public live run and enumerates the specific data returned: value over time, rules, last engine decision, and all trades. It also distinguishes this from the sibling list_live_runs by stating that the slug comes from that tool.

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

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

The description establishes that you need a slug obtained from list_live_runs, giving clear usage context. It does not explicitly state when not to use this tool or name other alternatives, but the prerequisite routing is sufficient for an agent to select it correctly.

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, openWorldHint, idempotentHint and non-destructive behavior. The description adds useful context that the data is read live from Binance when called and enumerates the returned metrics, but it omits rate limits, latency, and error behavior, so it is not fully 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 a single front-loaded sentence that names the returned data first and the live source second. It contains no filler and is appropriately sized for a simple quote tool.

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

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

There is no output schema, so the description's enumeration of returned fields is important and present. For a simple two-parameter read-only tool with rich annotations, this is nearly complete, though minor operational details such as rate limits or latency 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%, with symbol and venue already documented in the input schema. The description only reinforces the 'Binance pair' concept and adds no extra detail about the venue enum or symbol format 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 states a specific retrieval purpose: last traded price plus 24-hour change, high, low and volume for a Binance pair. It clearly identifies the resource and data returned, though it does not distinguish this tool from related siblings such as get_candles or get_indicators.

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

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

The description gives no explicit when-to-use guidance or alternatives. Saying it is read from Binance when called implies a live quote, but it does not tell the agent when to choose this over get_candles or get_indicators.

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

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

Annotations already declare this is a read-only, idempotent, non-destructive, open-world read. The description adds genuine context beyond that: the substance of what's returned (delivery verdict, rehire intent, paid-job vs on-chain provenance), which matters since there is no output schema. It still doesn't mention volume, ordering, or whether an agent with no reviews returns an empty set.

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

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

Two compact sentences with no filler; the content of the return is front-loaded. The trailing sentence on review eligibility is relevant context rather than waste, though it sits slightly awkwardly at the end of a description for a read tool.

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

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

With no output schema, the description carries the return-value burden and does a fair job describing the review fields and their provenance. Combined with one documented parameter and full read-only annotations, the definition is nearly complete; only aggregation/ordering or empty-result behavior is unaddressed.

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 the schema documents it at 100% coverage ('The agentKey (or token id)'). The description adds no meaning about the identifier or how to obtain it. With the schema doing the work, 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 makes clear this returns reviews left for a given agent, including whether it delivered, whether reviewers would rehire, and review provenance (paid job vs on-chain). It's a specific resource (agent reviews) with no ambiguous verb, though it's phrased as prose ('What people who hired an agent said') rather than a direct verb+resource statement. No sibling tool covers reviews, so no differentiation is strictly needed.

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

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

There is no guidance on when to call this versus alternatives — e.g., before deciding to call_agent or in conjunction with get_agent for reputation checks. The sentence 'Only a wallet that hired an agent can review it' describes who may post a review, not when an agent should invoke this tool, so it doesn't function as usage guidance.

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

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

Annotations already declare this as a read-only, idempotent, non-destructive, open-world operation. The description adds useful behavioral context by saying it returns rules, record, and recent trades, but it does not clarify recency, pagination, response shape, or any access constraints.

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

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

The description is two short sentences with no filler, and the core scope is front-loaded before the parameter-source note. Every sentence adds useful information.

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

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

For a simple, read-only tool with one required parameter and no output schema, the description gives enough to understand what the tool returns and where the id comes from. It could be more complete about the exact return structure or recency of trades, but the essential context is 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 0%, so the description must add meaning for the single id parameter. It usefully states that the id comes from list_traders, which clarifies the parameter's source and role. However, it does not describe format, expected type beyond string, or validation, leaving some semantic gap.

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

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

The description clearly identifies the specific resource: one trader, including their rules, record, and recent trades. It also implicitly distinguishes this from list_traders by noting that the id comes from that sibling. An explicit retrieval verb is absent, but the tool name and title make the action clear.

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 sentence 'id comes from list_traders' gives clear prerequisite guidance and points the agent to the correct sibling tool for obtaining the identifier. It does not explicitly state when not to use this tool or name alternatives beyond list_traders, so it falls short of full when/when-not guidance.

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

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

Annotations already declare read-only, idempotent, open-world, non-destructive behavior. The description adds useful return context ('how many live agents each has') and a downstream workflow hint, but does not cover output shape, pagination, or auth details.

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

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

Two short sentences, front-loaded with the returned resource and followed by the actionable next step. No wasted wording.

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

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

For a zero-parameter, read-only listing tool with no output schema, the description sufficiently explains what is returned and how to use the result. It could say more about the output structure, but the core completeness is adequate.

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

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

This tool has zero parameters, so the baseline is 4. The mention of passing a slug to search_agents is not a parameter of this tool, but it usefully explains how the output is intended to be consumed.

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: Dolphin marketplace categories, including live-agent counts. It is clear enough to distinguish from siblings like search_agents, though it does not explicitly say 'list' or name sibling alternatives directly.

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

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

It gives a clear workflow cue: use the returned slug with search_agents. It does not state when not to use the tool or compare alternatives explicitly, but the intended discovery role is 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?

Annotations already declare readOnlyHint/idempotentHint/non-destructive, so the safety profile is covered. The description adds real domain context the annotations cannot: runs can terminate when funds run out or the owner ends them, and real vs demo money with values sourced from BNB Chain versus a demo account. It does not mention result count, ordering, or whether ended runs are included.

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

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

Three tight sentences, front-loaded with the resource and its URL, then the distinguishing real-versus-demo mechanic, then the returned fields. Slight density in the parenthetical 'value read from BNB Chain' clause, but nothing is wasted.

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

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

For a parameterless read-only list with no output schema, the description supplies what the returned entities are, the two modes that shape their values, and the per-run fields (start, current value, status). That is enough for an agent to call it and interpret results 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?

Zero parameters, so there is no parameter semantics to explain and the baseline applies. The 'paper: false / paper: true' explanation is genuinely useful, though it describes a field on returned runs rather than an input, which could momentarily be misread as a filter since no parameters exist.

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 ('Public runs on dolphinamp.xyz/live') and explains what a live run actually is: an agent trading in public until its money runs out or its owner ends it. It doesn't explicitly contrast with the singular sibling get_live_run, but the plural listing intent 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?

Usage is implied by the word 'Public runs' and the sibling get_live_run, but there is no explicit 'use this when you want the list, use get_live_run for a single run' statement, and no note on ordering, limits, or when the list would be empty.

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

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

The annotations already cover the safety profile (readOnlyHint=true, destructiveHint=false, idempotentHint=true), so the description does not need to restate that. It adds valuable behavioral context by disclosing the returned trader types and included data: market, risk, maker, record, 90- and 365-day backtests, live results for community traders, and explicitly that losses are included. It does not mention pagination or response shape, but with rich annotations this is a strong 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, front-loaded sentence that begins with the core resource ('Every trader on dolphinamp.xyz/trade'). It is dense but each phrase adds useful scope information, though the parenthetical and colon-separated list make it slightly less readable than an ideal concise definition.

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

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

With no input parameters and no output schema, the description carries most of the burden of explaining what is returned. It does that well by enumerating trader categories and data dimensions, including backtest periods and live results. It could be more complete by specifying whether the return is a list or whether there are any limits, but it is sufficient for an agent to understand the tool's scope.

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

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

The tool has zero parameters, so there is no parameter schema to explain. The description appropriately contains no parameter details, and the baseline for zero-parameter tools is 4.

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

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

The description states a specific verb and resource: it lists every trader on dolphinamp.xyz/trade, covering both Dolphin's own and community traders, with associated market, risk, maker, and record data. It clearly describes what the tool returns but does not explicitly distinguish itself from sibling tools such as get_trader or search_agents, so it falls short of a 5.

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

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

The description implies it is a comprehensive listing tool by saying 'Every trader on dolphinamp.xyz/trade,' but it gives no explicit guidance on when to use this versus get_trader, search_agents, or best_strategies. There are no exclusions or alternative-selection criteria, leaving the agent to infer usage.

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

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

Annotations already declare readOnly, idempotent, non-destructive and open-world behavior, so the safety profile is covered. The description adds real value by disclosing what comes back (what each agent does, how it is used, and its cost), though it says nothing about result ordering or the 20-result cap's implications for coverage.

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: the first identifies and scopes the tool, the second describes the payload and the follow-up step. Nothing is repeated from the title or wasted.

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 return-value burden and does so at an appropriate level of abstraction, and all params and annotations are covered elsewhere. It is only slightly incomplete on result ordering/pagination, which matters for a capped list tool.

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

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

Schema description coverage is 100% — every parameter including the protocol enum is documented in the schema itself. The description adds no syntax or semantics beyond that, 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 verb and resource ('Find AI agents listed on Dolphin'), adds scope (BNB Chain, ERC-8004) and what the results contain, and explicitly distinguishes itself from get_agent, which is the drill-down sibling. An agent can tell this is a discovery/search tool and not a detail or invocation tool.

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

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

Gives clear usage context — search by need in a few words, empty query lists top agents — and routes the agent forward with 'Use get_agent next for an agent's tools.' It does not cover when to prefer alternatives such as list_categories or call_agent, so it stops short of full when/when-not guidance.

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

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

Annotations already establish this is a non-destructive read (readOnlyHint=true, destructiveHint=false), so the description's job is to disclose the simulation's assumptions — and it does: live rule engine, PancakeSwap fees, BNB Chain gas, fixed $100 sample, 4h candles, one-year window, plus a buy-and-hold benchmark. It omits anything about latency, rate limits, or that openWorldHint means the result depends on live market data, which keeps it off 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 rhetorical opening 'Would this simple strategy have made money over the last year?' frames the tool before the technical detail, and the entry-rule enumeration is dense but necessary. A few clauses (the dolphinamp.xyz/test reference) do not earn their space for an agent, but overall there is little waste.

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 saying the result is compared with just holding the coin, which hints at the shape of the answer. It also fixes the ambiguous inputs (timeframe, capital, fee model) that would otherwise be unknowable. It does not say what metrics come back (return, drawdown, trade count), which is the remaining gap for a tool with no return-value 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 coverage is 60%, and the description compensates well for the undocumented `entry` enum by spelling out all four modes (dip, rsi, trend, momentum) and how `level` is interpreted in each. It also clarifies that target and stop are percentages measured from the entry. The allowed level/target/stop value sets live only in the schema, and `coin` is left unexplained, so it is good rather than exhaustive.

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

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

The description states a specific verb+resource: it replays a preset entry strategy over the last year of Binance 4h candles with Dolphin's live rule engine, fees and gas on a $100 sample, and compares against buy-and-hold. That is far more specific than the name alone. It never names the closest sibling (backtest_rule) or explains how this preset-strategy test differs from a custom-rule backtest, so it stops short of a 5.

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

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

Usage is only implied: the four entry presets with their allowed `level` values suggest this is the tool for quick, pre-built strategy checks, and 'Give a target and/or a stop' tells the agent how to complete a call. There is no explicit when-to-use versus backtest_rule or best_strategies, and no statement of what to do if the parameters are invalid.

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