Akari Crypto Intel

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

With no annotations, the description carries the full burden, yet it discloses no behavioral traits beyond a list of gotchas. Notably it says 'drop in your image and port, get a working manifest' while the schema accepts zero parameters, so the described interaction cannot happen — a misleading claim about behavior.

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

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

The failure-mode list is genuinely useful and front-loaded information, but the surrounding marketing framing ('the exact ... we used to put a live container', 'cost us real attempts', 'from our own lease') pads a short payload. Roughly half the text 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 and no parameters, the description must fully specify what comes back; it names deliverables (SDL, manifest, proof URI, runbook) but not their form or whether they are returned inline or as files. The stated failure modes are substantive and partially compensate.

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 is empty (0 params), which normally sets a baseline of 4, but the description actively asserts the caller supplies 'your image and port.' That contradicts the schema and would lead an agent to look for inputs that do not exist, so it detracts rather than adds.

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

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

The description identifies the resource as an Akash deployment kit containing SDL, boot-test, and a lease runbook, but never states the concrete action the tool performs (does it return a document, a file, a template, generated config?). 'Deployment kit' is a bundle noun rather than a verb+resource, so an agent cannot confidently predict the output.

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

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

There is no statement of when to call this versus alternatives, despite a sibling named akari_launch_kit that sounds closely related. The 'drop in your image and port' phrasing implies an interactive workflow without saying when that workflow is appropriate or what preconditions exist.

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

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

With no annotations, the description carries the full burden, and it does disclose an important trait: the call costs $1.00 via x402. It also lists the brief's contents, implying a read-only report, but it never explicitly states read-only behavior, payment failure handling, or whether the charge applies per call.

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 with no wasted preamble, listing the brief's components before the price. Some terms like 'armed fixtures' and 'gate set' are jargon that could slow an agent, but the structure is 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?

For a tool with two undocumented optional parameters, no annotations, and no output schema, the description leaves key context missing: how equity and risk_pct affect the brief, and what the payment flow requires. It does enumerate return contents and state the price, but that is not enough to call it complete.

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

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

Schema description coverage is 0% and the description does not mention the two parameters at all. An agent gets no guidance on what 'equity' or 'risk_pct' mean, their units, or that they are optional, so the description fails to compensate for the schema 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 names the resource precisely as a 'Decision brief' and enumerates its contents (market regime, ranked funding-carry edges, avoid list, stand-down reasons, armed fixtures), so an agent knows what it produces. It does not explicitly distinguish itself from the many sibling akari_* tools, which keeps it below a 5.

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

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

There is no statement of when to use this tool versus alternatives such as akari_trade_plan, akari_market_report, or akari_board. The word 'Decision brief' hints at decision-support usage, but no explicit context or exclusions are given.

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

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

With zero annotations the description carries the full load, and it does disclose real behavioral substance: it runs the full per-route probe, the output is keyed finding-by-finding with the exact change (header, JSON field, file path), and two free re-verification runs are included within 30 days. Left undisclosed are cost/payment terms (significant given the x402 framing), runtime, and 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?

It is front-loaded with the deliverable, which is correct. But the em-dash run-on crams probing, plan contents, cost estimates, and re-verification into one breath, and phrases like 'so the fix is provable' and 'defects they cannot see' are sales copy rather than operational 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?

It explains the deliverable well, which matters because there is no output schema. The critical hole is that a zero-parameter tool auditing 'per-route' never says how the target endpoint/site is identified (account config? auth context?), leaving the agent unable to confirm preconditions for invocation.

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

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

The tool takes no parameters (additionalProperties: false, empty properties), so there is nothing for the description to disambiguate; the zero-parameter baseline applies. No parameter-facing claims are made or contradicted.

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: a full per-route x402 audit plus a prioritised remediation plan. An agent can tell what comes out (findings keyed to exact fixes and estimated buyer-share cost). It never differentiates from the obvious sibling akari_endpoint_audit, so the reader cannot tell which audit tier to pick without opening both 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?

The closing line scopes the audience (sellers already serving a live 402 and losing buyers to invisible defects), which implies when to reach for it. However, there is no explicit when-not-to-use and no named alternative, even though akari_endpoint_audit sits right beside it in the sibling list. Usage is inferred rather than stated.

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

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

With no annotations, the description carries the full burden. It discloses the 50-address cap, Base-only ETH/USDC scope, dual GET/POST input formats, and 50% pricing, but does not cover authentication/payment requirements, rate limits, or failure behavior for invalid addresses.

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 purpose, capacity, price, and input formats are front-loaded in the first two sentences. The second sentence about 'pipeline agents, x402 payer-vetting observatories and copy-trade desks' is somewhat marketing-heavy, but the use-case list that follows earns its space.

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 no annotations, but the description states the returned assets, network, input formats, cap, and pricing. It is sufficient to invoke the tool correctly, though it leaves gaps around payment/auth and response/error shape.

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 input schema is empty, so the baseline is 4. The description adds important meaning by documenting the `addresses` input, the maximum of 50 EVM addresses, and both `?addresses=0xA,0xB,…` and POST `{"addresses":[…]}` syntax. This compensates for the schema being effectively silent, though the schema's `additionalProperties: false` creates ambiguity.

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: bulk wallet vetting returning Base ETH and USDC balances for up to 50 EVM addresses. It clearly distinguishes batch from per-address calls via the 'ONE call' and '50% of the single-call price' framing, though it does not name a specific sibling tool as the single-address alternative.

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

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

Explicitly lists use cases: batch wallet health checks, airdrop/allowlist screening, payer vetting at scale, and treasury monitoring. The batch-vs-single distinction is implied through price and throughput, but there is no explicit 'do not use for a single address' exclusion.

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

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

With no annotations, the description carries the full disclosure burden. It usefully states the tool is free/no-payment and returns text rather than structured data, but omits freshness/latency of 'live' data, whether the board is a snapshot, and any auth or rate-limit context.

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

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

A single compact sentence with the key qualifier ('FREE') front-loaded and the return contents enumerated parenthetically. No filler or restated name.

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, no-output-schema read tool, the description is nearly sufficient: it lists the summary's contents so the agent knows what comes back. It falls short on defining 'live' freshness and how this board differs from related akari summaries.

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 there is nothing to misdescribe; baseline 4 applies. The description correctly implies a no-argument call and adds return-content hints instead of redundant parameter text.

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

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

The description names a specific resource (live edge board) and states the output form (text summary) plus its contents (verdict, regime, passing edges, refusals). The purpose is clear enough to act on, but it never distinguishes itself from sibling tools like akari_desk_state or akari_alpha_brief, leaving overlap ambiguous.

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?

Beyond 'FREE: ... No payment,' there is no guidance on when to call this versus the nineteen sibling akari_* tools, no preconditions, and no exclusions. The agent must infer selection from the name alone.

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

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

With no annotations, the description carries the full burden. It does disclose the return shape (JSON with per-host rows) and that the dataset is a dated snapshot (727 hosts on 2026-10-28), which implies a read-only, non-live operation. It omits freshness/staleness semantics, payload size, and whether the census is re-probed on each call or served from a fixed snapshot.

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 resource is front-loaded, but the single run-on sentence carries marketing puffery ('the only graded census', 'drops straight into a pitch list or a board report') that doesn't help an agent decide or invoke. The substantive content could be stated in half the length.

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-param report with no output schema and no annotations, the description does the necessary work: it explains what rows come back, what the grades and defect ids are, and that the output is JSON. Only the snapshot-vs-live question and payload scale are left open.

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 nothing for the description to disambiguate. The enumeration of what the report contains is helpful context but is not parameter semantics.

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

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

States a concrete resource — a graded census of the CDP Bazaar discovery index — and enumerates its contents (per-host probe results, live-402 counts, A-F grades with defect ids, defect distribution). The 'report/census' verb-resource framing is clear, though it never explicitly contrasts itself with the many sibling akari_* report 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?

Usage is implied through audience ('directory operators, facilitators, and anyone deciding which sellers to court') rather than stated as when-to-call conditions. No alternatives among the siblings are named and no exclusions are given, so the agent must infer fit from the audience framing.

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

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

With no annotations at all, the description carries the full behavioral burden; it does disclose the shape of what comes back (perps where funding and crowd bias agree, plus the funding-collecting side), which implies a read-only analytical output. It says nothing about data freshness, update cadence, latency, or coverage limits, which matter for a cross-source signal tool.

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

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

Two tight sentences: the first front-loads the data sources and the filter logic, the second front-loads the intended use cases. No filler and nothing buried.

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

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

With no output schema and no annotations, the description is the only disclosure layer, and it does explain the returned fields well enough to interpret results. It is missing operational context (read-only status, freshness, any limits) that would make it fully self-sufficient.

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

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

The tool takes zero parameters, so there is no parameter meaning to add and the baseline of 4 applies. The description correctly implies no inputs are needed, since it describes only the returned set.

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

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

The description names a precise verb+resource: it crosses Hyperliquid perpetual funding rates with Reddit sentiment and returns perps where the two signals agree, along with which side collects funding. That is specific enough to distinguish it from siblings like akari_reddit_sentiment and akari_hl_market, which each cover only one input.

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 states the situations it serves — funding-rate arbitrage ideas, funding harvest signals, and perp carry trades — which gives an agent clear context for reaching for it. It stops short of naming alternatives or exclusions, so an agent must infer that single-source sentiment or market queries belong to the sibling tools.

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

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

No annotations, so the description carries the full burden. It discloses a lot of behavioral detail — a ~50-minute observation window, the classification label set, and the GET-query vs POST-body dual invocation. It is silent on auth requirements, rate limits/cost, and what happens with an unknown or malformed address, which matter for a paid intelligence endpoint.

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: purpose first, then the invocation form, then the returned fields, then the classification set. It is a long single block and could be split into discrete sentences, but nearly every clause carries information an agent needs.

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

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

With no output schema and no annotations, the description does the heavy lifting by enumerating the return fields and the exact classifier labels, which is exactly what an agent needs to decide relevance. Remaining gaps — error behavior, auth, and the GET/POST vs zero-parameter schema conflict — are modest but real.

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 declares zero properties with additionalProperties:false, so the description is the only source of the required address argument and its two transport forms (?address=0x… on GET, {"address":"0x…"} on POST) — information the schema cannot supply. This is above the 0-param baseline, though it sits in tension with the schema's closed-object declaration rather than resolving 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 resource (deep wallet profile) and enumerates exactly what is returned: ETH+USDC balances on Base, tx count, contract detection, ~50 minutes of USDC payment flows, counterparty concentration, and a classification taxonomy. An agent knows precisely what it gets. It does not, however, distinguish itself from sibling akari_wallet_intel, which is presumably the closest alternative.

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

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

Usage is implied by 'x402 payer intelligence' — profile a wallet to judge whether it is an autonomous-agent payer. But with 20 siblings including akari_wallet_intel, the description offers no when-to-use/when-not or alternative routing, leaving the agent to infer which wallet tool to pick.

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

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

With no annotations, the description carries the full disclosure burden, and it does substantial work: it identifies data provenance ('raw clearinghouse state', 'latest desk mark', 'v7.5 trade veto') and marks the payload as a point-in-time snapshot of live externals, which tells the agent values drift between calls. It omits explicit read-only/no-side-effect confirmation, caching or rate-limit behavior, and failure modes when a venue is unreachable, so it is not complete.

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 lead clause is well front-loaded and tells the agent immediately what this is. But the body is one marathon sentence enumerating seven data domains, and the text is visibly truncated mid-word ('currently positio'), which leaves the reader unsure whether a clause was lost. The enumeration earns its place; the packing and the truncation do not.

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

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

There is no output schema, so the description must describe return values — and it does, domain by domain, which is exactly the right compensation. The main shortfall is the truncated final clause and the absence of any note on payload size or partial-failure behavior for an aggregate that stitches together multiple external venues.

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 there is nothing for the description to disambiguate and the baseline of 4 applies. The description correctly implies the entire desk scope is returned unconditionally, with no filtering options to explain.

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 live trading desk state snapshot — and enumerates exactly what it returns: Hyperliquid equity and perp positions, Polymarket cash and combined desk value, armed fixtures, stake ladder, sentiment veto vector, and edge tape rows. That is far more specific than a sibling like akari_hl_market or akari_inplay_edge, which appear to cover single slices. It does not explicitly name which sibling to use for the narrower slices, 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?

'Use for desk mirroring, copy-trading context, or checking what a live trading agent is currently positio[ned]' gives concrete positive use cases, which is more than most definitions. However there are no exclusions or routing rules — nothing says when to prefer akari_inplay_edge or akari_hl_market for a single data slice instead of pulling this whole aggregate. Usage is implied by the content list rather than prescribed.

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

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

With no annotations, the description carries the full burden and mostly succeeds: it discloses the exact checks performed and the return shape (findings with severities, a 0-100 score, a fix list) plus latency measurement. It omits whether the tool requires credentials, whether it has side effects on the target, rate limits, or cost — and the trailing truncation ('what breaks a ') cuts off information.

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

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

Purpose is front-loaded and the enumeration of checks is useful content, but the definition is a single dense run-on sentence that ends truncated mid-clause. The unclosed 'Use when you sell an x402 endpoint and want to know what breaks a ' is dead weight the agent cannot parse.

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 compensate by naming the return shape (severities, 0-100 score, fix list), which is the most valuable addition here. Against that, it never states the invocation contract correctly given the empty schema, provides no sibling disambiguation among 19 akari_* tools, and is cut off before finishing its usage guidance, leaving real gaps for a network-calling audit 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 description instructs the caller to 'pass ?url=https://your.host', implying a required url parameter, but the input schema declares zero properties with additionalProperties: false — so a url argument would be rejected. This direct mismatch between the described input and the actual schema is worse than saying nothing. The 0-param baseline of 4 does not apply because the description actively misdirects.

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: audit an x402 paid endpoint and return a per-route report. The enumerated checks (402 status, payment header decode, positive amount, CAIP-2 network, payTo, human-readable price, MCP surface, latency) make the scope concrete. It does not differentiate itself from the many akari_* siblings (e.g. akari_audit_plus, akari_deep), so an agent has no textual basis for choosing between audits.

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?

Offers a trigger condition ('Use when you sell an x402 endpoint and want to know what breaks a ...'), which implies usage but stops mid-sentence, so the condition is incomplete. No exclusions, no named alternatives, and nothing to distinguish it from akari_audit_plus or akari_deep.

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

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

No annotations are provided, so the description carries the full burden. It does disclose useful traits: versioned schema (akari.feed.v1), a free 3-row preview path, and a schema URL, implying a read-only data fetch. However, it omits cost/rate-limit details, digest size, and freshness/latency of the signals, which matter for a trading feed.

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

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

Purpose is front-loaded in the first clause, followed by the source list, then endpoints, then the usage rule — a sensible ordering. It is somewhat dense with marketing-flavored phrases ('armed Polymarket in-play sports betting picks'), but no sentence is genuinely dispensable.

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

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

Given a zero-parameter, annotation-free, output-schema-free tool, the description covers what comes back (one versioned JSON digest), what it combines, and where to find the exact schema — everything an agent needs to decide and call 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; there is nothing for the description to disambiguate. The mention of the preview endpoint and schema path is bonus context, not required parameter documentation.

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 ('Consolidated crypto trading signal feed') and enumerates exactly what is merged: Hyperliquid funding+momentum signals, Reddit sentiment bias, meme coin radar, and Polymarket in-play picks. This makes it unmistakably the aggregated counterpart to the single-source siblings like akari_reddit_sentiment and akari_meme_radar.

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?

"Use this when you want one cheap call instead of five" gives a clear selection condition against the per-source sibling tools. It stops short of explicit exclusions (e.g., when to prefer a single-source tool for deeper detail), so it is strong but not fully symmetric.

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

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

With no annotations, the description carries the burden well: it discloses the upstream source (Hyperliquid /info), a 30s cache, an approximate dataset size (~180 coins), and that aggregate top-5 funding extremes plus chain-wide totals are appended. It omits failure/auth behavior, keeping it short of a 5.

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

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

Densely packed but front-loaded: purpose first, then query modifiers, then provenance and caveats. The text is cut off mid-word, which leaves the final usage sentence incomplete and slightly undermines an otherwise efficient structure.

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?

Return shape is described field-by-field, so the absence of an output schema is covered, and source/cache/aggregates give the agent enough to interpret results. The gap is the unresolved conflict between the advertised query parameters and an empty input schema.

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

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

The schema declares zero properties with additionalProperties=false, yet the description instructs the agent to filter via ?coins=, ?sort=, and ?limit=1-300. This invites calls the schema explicitly forbids, which is a real risk of malformed invocation; the baseline of 4 for zero params is undercut by the mismatch.

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 precise verb+resource ('Hyperliquid perpetuals market snapshot') and enumerates the exact fields returned per coin. It is unmistakably distinct from siblings like akari_ta or akari_market_report because it names the specific venue and data surface.

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 advertises concrete filtering/sorting/capping options (?coins, ?sort, ?limit) and begins a use case ('Use for funding-harvest sc...'), but the sentence is truncated and no sibling alternative or exclusion is named. Usage is implied rather than 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?

No annotations are provided, so the description carries the full disclosure burden. It does explain the underlying model, live/armed match scope, leagues, output fields, and auto-fire threshold, but it omits freshness, rate limits, auth requirements, and whether the tool is strictly read-only.

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 and dense, but it is truncated mid-phrase ('in-play predictio') and includes marketing-style language about losses that does not help an agent select or invoke the tool.

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

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

For a no-parameter data-retrieval tool with no output schema and no annotations, the description covers the core signals and leagues but does not fully specify return format, data freshness, or coverage limits, and the truncated ending leaves the usage statement incomplete.

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 are no parameter semantics to clarify. Per the rubric, a zero-parameter tool receives a baseline of 4 when the schema coverage is complete.

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

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

The description names a specific resource and data type: Polymarket in-play soccer betting edge signals, with leagues, model-vs-market comparison, edge percent, ask price, and the 12% auto-fire bar. It is clearly distinct from the unrelated sibling tools, though it does not explicitly differentiate itself from them.

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

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

It provides explicit use cases: 'Use for Polymarket edge hunting, sports betting model predictions, and in-play predictio[n]...' This gives clear context for when to invoke it, but it does not name exclusions, alternatives, or prerequisites.

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

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

With no annotations, the description carries the full burden, and it does disclose useful behaviour beyond the name: output is generated deterministically, no LLM is involved, no invented facts, and compliance notes exclude price promises. However, it says nothing about failure modes, auth, rate limits, or why the tool declares zero input properties when it advertises query-string inputs.

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 output inventory is front-loaded, which is good, but the single sentence is overloaded and the trailing usage guidance is truncated ('in one '), leaving a visible defect. It could be split into what-it-returns and how-to-invoke clauses without losing content.

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

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

With no output schema and no annotations, the description correctly spends its budget enumerating return values, so an agent knows what it will get back. The remaining gap is the contradiction with the empty input schema, which the description never resolves.

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 is strictly empty (additionalProperties: false, 0 properties), yet the description advertises name, ticker, chain, narrative, audience, url and x as inputs. That is actively misleading: an agent following the description will try to pass arguments the schema rejects, and there is no explanation of how the 'YOUR facts' are actually supplied.

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

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

States a specific resource (launch copy kit for token/agent projects) and enumerates the exact deliverables: 3 taglines, an X post with char count, a 3-post thread, Telegram/Discord announcements, a listing blurb and hashtags. Nothing in the sibling list (market reports, audits, sentiment feeds) overlaps with this, so an agent can distinguish it immediately.

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?

'Use it when a project needs launch copy in one [call]' implies the trigger, but the sentence is cut off mid-thought and no alternative or exclusion is named. There is no guidance on prerequisites, on what to do when facts are missing, or on how this relates to any sibling tool.

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

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

With no annotations, the description carries the full burden. It does add useful provenance ("from this server's own hit log, our own checks excluded") and signals a live-measurement nature ("actually serve", "really reach"). It does not state that it is read-only, whether results are cached or how fresh they are, or any cost/rate considerations – gaps that matter for a data-gathering call.

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?

It is a single packed sentence, front-loaded with the tool's identity and then the report contents, with zero filler. The clause-heavy structure (multiple "plus which..." additions) makes it slightly dense to parse, which keeps it from a 5.

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, but the description effectively enumerates what the report returns (counts, grades, worst/cleanest sellers, UA/referer data), so an agent knows what to expect. Missing only ancillary details like response format and data freshness for a fully complete picture.

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. The description correctly presents it as a parameterless report; no parameter meaning needs to be conveyed.

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

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

The description names a specific resource (x402 seller market report) and enumerates its contents precisely: valid-challenge counts, dead endpoints, grade distribution, worst/cleanest sellers, and hit-log user agents/referers. This is far from a restatement of the name. It does not, however, explicitly distinguish itself from siblings like akari_endpoint_audit or akari_hl_market, which an agent might reasonably consider for similar-sounding checks.

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?

"Use it to decide where placement pays before you spend on promotion" gives a clear, concrete decision context. There is no explicit when-not-to-use guidance or named alternative for endpoint-level checks, which keeps it below a 5.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the data source (crypto social feeds) and chain coverage (Base and beyond), but says nothing about read-only semantics, rate limits, data freshness, or what a 'hype ratio' actually measures.

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 described before the usage guidance, so it is well front-loaded. Minor redundancy from repeating 'meme coin' in both sentences keeps it from a 5.

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, non-destructive lookup with no output schema, an agent knows what it returns (trending meme tokens plus hype ratios) and what it is for. It could still say more about the returned fields or refresh cadence, which is the only remaining gap.

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 nothing for the description to disambiguate. The description correctly implies the tool is a fixed, no-argument snapshot call.

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

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

The description names a specific resource and output shape: trending meme tokens with hype ratios from crypto social feeds. That is far more informative than the name alone and clearly separates it from sentiment/market siblings like akari_reddit_sentiment or akari_hl_market, though no sibling is named explicitly.

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

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

The second sentence explicitly states the use cases — meme coin momentum scanning and degen ticker discovery on Base and beyond — which gives a clear selection context. It offers no exclusions or named alternatives, so it stops short of a 5.

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

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

With no annotations, the description carries the full burden and does well: it discloses the $5.00 charge, the 30-day window, the 5,000-call fair-use cap, the bearer-token return, and the /pass/x402 routing behavior. It stops short of stating how payment is actually settled, whether it auto-renews, or what happens when the call cap or 30 days is exhausted.

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

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

Front-loaded with the offer and price, then the return value, then the usage rationale — a sensible order. The full route enumeration (feed, wallet-intel, TA, ...) is somewhat verbose given 'every paid route' already covers it, though it usefully ties back to the sibling tool names.

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 explaining the returned bearer token and the exact Authorization header to use on subsequent calls. Only gap is post-purchase failure/expiry behavior, which an agent might need before committing $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?

The schema has zero properties, so there is nothing for the description to disambiguate; baseline for a no-parameter tool is 4. The description correctly implies the only input is the act of purchase itself.

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 (Desk Pass) with concrete economics: one $5.00 payment for 30 days of access to every paid route, capped at 5,000 calls. The enumerated route list and the bearer-token return value make it unmistakable versus the sibling per-route tools like akari_feed or akari_ta.

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 trigger ('Use when an agent polls on a schedule') and quantifies the alternative: at $0.02/call, hourly polling costs $14.40/month, so the pass is the cheap path. The per-call route siblings are the named alternative, and the cost math supplies the when-not condition implicitly.

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

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

No annotations are provided, so the description carries the full disclosure burden. It does add valuable behavioral context — the endpoint is paid, a free preview exists, and picks are historically settled — but it does not state access/auth mechanics, whether results are cached or time-sensitive, or how many picks are returned. Adequate but with clear gaps.

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 the tool's identity and screening rule, then the preview/payment caveat. Dense but each clause contributes. Slightly compressed punctuation keeps it from a 5.

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 must describe the return payload, and it does: model probability, ask, edge, and settled hit-rate. It also explains the qualifying threshold and the free-record preview, which is enough for an agent to call and interpret the result. Minor omissions around freshness and result volume keep it at 4.

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 there is nothing to disambiguate at the input layer. The description correctly does not waste space inventing parameters, which meets the baseline for a no-param tool.

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 (today's football picks) and the precise qualifying criterion: a last-6-form Poisson model beating the live Polymarket moneyline by 10+ points. It also enumerates the returned fields (model probability, ask, edge, settled hit-rate). It does not, however, distinguish this from the many sibling akari_* tools such as akari_inplay_edge or akari_alpha_brief, so an agent must infer the boundary.

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 clear contextual guidance: check the free /x402/picks/preview settled record before paying, and 'never take a pick without it.' That tells the agent a prerequisite step, but it never says when to choose this tool over sibling analysis tools, nor does it name any alternative.

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

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

With no annotations, the description carries the full burden. It does disclose the nature of the result (ranked tickers, bull/bear ratio, directional bias), which implies a read-only scan, but says nothing about data freshness, which subreddits or time window are covered, rate limits, or any auth requirement.

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, front-loaded with what the tool returns and followed by when to use it. Minor redundancy in repeating 'crypto sentiment' / 'crypto social feeds', but 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 tool with no output schema and no annotations, the description should describe the shape and scope of what comes back. It names the ranking metric and bias fields but omits any time window or coverage scope, which materially affects how an agent interprets a sentiment 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline of 4 applies. Description correctly requires no inputs, consistent with 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?

States a specific resource and operation: a Reddit crypto sentiment scan producing top tickers ranked by bull/bear ratio with LONG/SHORT bias. An agent can tell this is a sentiment/positioning read rather than a market-data or signal-execution tool, though it never names which sibling to prefer over it.

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 trigger conditions — social sentiment, crowd positioning, bullish/bearish read — which is clear usage context. It stops short of exclusions or pointing to alternatives (e.g. akari_feed or akari_confluence) for adjacent needs.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It lists the signal contents but does not clarify whether the tool only returns a signal or actually executes a trade, nor does it mention permissions, freshness, rate limits, or side effects. For a tool named 'execute' in a trading context, that ambiguity is significant.

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, front-loads the resource and output contents, and then gives the usage condition. There is no filler, and every phrase contributes to understanding what the tool provides.

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

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

With no output schema and no annotations, the description must carry more of the return-value and behavior explanation. It does list several signal fields, but it leaves out the output format, field meaning, freshness, and the crucial question of whether the tool places an order. It is minimally adequate for a zero-parameter signal tool but not fully complete.

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

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

The tool has zero input parameters, so there are no parameter semantics to document. The baseline score of 4 is appropriate because the schema requires no invocation 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 states a specific resource: the funding+momentum confluence engine's current best setup as a complete trading signal, including side, basis, entry parameters, and leverage cap. It distinguishes the output from raw data, but does not differentiate from specific siblings such as akari_confluence or akari_trade_plan, and the tool name 'execute' creates some ambiguity about whether it executes or merely returns a signal.

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

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

The phrase 'Use when you want a ready trading signal, not raw data' gives general when-to-use guidance and an implicit when-not-to-use condition. However, it does not name alternatives or clarify how this differs from similarly named siblings like akari_confluence, akari_trade_plan, or akari_hl_market.

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

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

With no annotations, the description carries the full burden and does disclose useful behavioral traits: the data source (TradingView screener), freshness (live), a latency figure (~0.2s), the default scope (top 12 majors) and a hard cap (up to 20 symbols). It omits rate limits, failure behavior for invalid tickers, and whether composite bias recalculates per-symbol, so it stops short of a 5.

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

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

The output-field list is front-loaded and information-dense with little padding. But the final clause, 'Use for TA', is an unfinished sentence that dangles rather than instructing, and the long parenthetical could be split for easier scanning.

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 and no annotations mean the description must cover returns and behavior, and it does describe the returned fields and the composite bias/trend tag vocabulary well. The remaining gap is mechanical: nothing reconciles the described ?symbols input with the empty, additionalProperties=false schema, which leaves an agent unsure whether it can pass filters at all.

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 description explains the ?symbols parameter thoroughly (cap of 20, default 12, BINANCE pairs, bare tickers like HYPE or full BINANCE:HYPEUSDT). However, the input schema declares zero properties with additionalProperties=false, so the only documented parameter cannot be expressed through the schema — an agent must guess it appends a query string. The semantics are good but contradict the structured contract, so the 0-param baseline of 4 is not warranted.

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?

A precise verb+resource statement: a TradingView technical-analysis snapshot for crypto, with the exact fields it returns enumerated (per-timeframe ratings, RSI, ATR/ATR%, 24h change, volume, 52w range, composite bias, trend tag). It is highly specific, but never names or contrasts against any sibling (akari_confluence, akari_deep, akari_market_report, akari_trade_plan), so the agent must infer where this sits versus those.

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 guidance is a truncated fragment, 'Use for TA', which adds essentially nothing beyond the name. No when-to-use conditions, no when-not, no named alternatives among the 19 sibling tools that plausibly overlap (akari_confluence, akari_trade_plan, akari_market_report).

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

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

With no annotations at all, the description carries the full burden, and it does disclose a lot about the payload: leverage is capped at 3x, stops are ATR-based, targets are 1.5R, exits are reduce-only, and gating covers funding, momentum, TA veto and sentiment veto. What it never resolves is the most important trait — whether calling it only produces specs or actually places an order — nor whether auth/wallet context is required. The text also truncates mid-word ('and ex'), cutting off any remaining 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 opening sentence is well front-loaded, but the body degenerates into one very long dash list that mixes inputs, outputs, pricing math and gate logic in a single breath. The description is visibly truncated ('and ex'), so the structure does not survive intact and the reader loses whatever came last.

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

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

With no output schema and no annotations, the description must explain the return payload, and it largely does — a real strength. But it omits whether the order is transmitted, how equity/risk budget is sourced, and what happens on a veto (does the tool still return a ticket?), leaving genuine gaps for a zero-arg, opaque tool with 19 siblings.

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

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

The tool takes zero parameters and the schema has full coverage, so there is nothing for the description to disambiguate. Baseline 4 is appropriate; the mention of 'the caller's equity and risk budget' at least signals that sizing inputs come from server-side context rather than arguments.

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 concrete deliverable: executable Hyperliquid order tickets with a full enumerated payload (coin, side, book pricing, IOC limit, size, leverage cap, ATR stop, 1.5R target, gate trace). The phrase 'not just a signal' hints at the boundary with akari_signal_execute, but no sibling is named, so the agent must infer the split between planning and execution.

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 tool is aimed at 'a trading agent' that needs to place a trade. There is no explicit when-to-use / when-not, no prerequisites (account, equity, risk budget source), and no pointer to akari_signal_execute or akari_hl_market as the alternative path. An agent can guess the context but cannot be certain it is the right entry point.

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

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

With no annotations, the description carries the full burden; it discloses that data is live via raw RPC and scoped to Base, which is useful behavioral context. However, it says nothing about rate limits, failure modes for invalid/non-EVM addresses, or what the response contains, leaving meaningful gaps for a read tool with zero annotation 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 tight sentences with the core capability front-loaded, then usage and the escalation path. The inline URL path detail is slightly noisy but costs little and aids disambiguation.

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 and no annotations, so the description must convey return shape on its own; it names ETH and USDC balances but not the other fields an agent would receive. It also leaves the address-passing mechanism ambiguous against an empty schema, making it only adequate for a tool whose only input is undocumented structurally.

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 declares zero properties with additionalProperties=false, yet the description instructs to 'pass ?address=0x…', so it does supply the one input the schema omits. That is valuable, but it also creates tension with the structured schema (the address has no declared slot), so it does not cleanly earn the zero-parameter baseline of 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?

States a specific verb+resource — on-chain wallet intelligence for any EVM address on Base, returning live ETH and USDC balances via raw RPC. It also differentiates scope from a richer variant (the deep path adding payment flows, counterparties, agent classification), so an agent can tell the two apart.

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?

Enumerates concrete use cases: wallet health checks, balance lookups, funding verification, and x402 payer vetting. It names the alternative (the deep variant) and what extra it provides, though it gives no explicit 'when not to use' or prerequisites (e.g., rate limits, chain restrictions beyond Base).

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