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

No annotations are provided, so the description must carry the full behavioral burden. It only says 'Add a token' and does not disclose idempotency, duplicate handling, authorization requirements, or side effects. This is a mutation tool with no additional behavioral transparency.

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

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

The single sentence is brief but not truly concise – it omits essential context while adding no fluff. This is under-specification rather than efficient summarization, so it does not fully earn its place.

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

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

For an action tool with two required parameters and no output schema, the description provides minimal guidance. It does not indicate the return value, success or failure conditions, or any additional expectations, leaving the agent without enough information to handle the tool's outcome correctly.

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

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

Schema description coverage is 0%, and the description makes no attempt to explain 'tokenAddress' or 'networkId'. The phrase 'Add a token' only vaguely maps to 'tokenAddress', and the required 'networkId' is entirely omitted. The description fails to provide any meaning beyond the schema's type declarations.

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 ('Add') and resource ('token to the watchlist'), which distinguishes it from fomo_remove_watchlist and fomo_get_watchlist. However, it does not specify whose watchlist or that it targets the current user's watchlist, which creates slight ambiguity.

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 is provided on when to use this tool versus its siblings, such as fomo_remove_watchlist or fomo_get_watchlist. There is no mention of the operation or context, so an agent cannot determine the right choice based on this description 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only implies a read operation through the word 'holdings' but says nothing about response shape, denominations, permissions, rate limits, or edge 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 description is short and front-loaded, but it is under-specified rather than concisely complete. It contains no actionable detail and reads more like a label than a tool 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 annotations, no output schema, and 0% parameter documentation, the description is insufficient for confident invocation. The agent can guess it returns token holdings but cannot determine what is returned or what the networkId means.

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% for both parameters, and the description does not explain tokenAddress or networkId. 'For a token' only loosely maps to tokenAddress, and networkId is completely unexplained, leaving the agent unable to understand network scoping or required values.

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 resource ('dev holdings') and a scope ('for a token'), so it is not a pure tautology. However, it is a noun fragment with no explicit verb, and 'dev' is left undefined, making the purpose vague and easy to misread.

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 use this tool versus a sibling like fomo_top_holders, fomo_get_balances, or fomo_friends_holdings. The only usage signal is the phrase 'dev holdings,' which does not clarify selection criteria, prerequisites, or exclusions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'batch token market data' with no details on response format, error handling, rate limits, order of results, or whether it returns a list of objects for the requested IDs. The behavior of the tool is almost entirely unspecified, leaving an agent unable to predict the outcome.

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, short sentence that is concise but under-specified. It front-loads the main action ('batch token market data'), but it omits essential context that would justify its brevity. The lack of structure (no separation of purpose, usage, output) and the extremely limited detail make it under-described rather than appropriately concise.

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 that the tool has one parameter and no output schema, the description should at least specify what data is returned (e.g., price, volume, market cap) and any batch behavior (limits, ordering). It provides none of this. The tool likely returns a sizable payload (array of market data objects), but an agent cannot infer the structure or content. The description is completely inadequate for effective usage.

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 exposes one parameter, 'tokenIds', an array of strings. The description's phrase 'by token id' confirms these are token identifiers, but it does not clarify what format they should take (e.g., contract address, internal ID, base58 string) or any constraints (min/max array length). With 0% schema description coverage, the description must compensate but only offers a minimal hint about the parameter's role.

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 verb ('get') and resource ('token market data') and implies a batch operation, which distinguishes it from single-token tools in the sibling list. However, 'market data' is vague—it does not specify whether it returns price, volume, liquidity, or other metrics. It is clear enough to know it fetches data for multiple tokens, but not precise enough to fully differentiate from tools like fomo_token_details or fomo_trading_activity without inspecting 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?

There is no guidance on when to use this tool versus alternatives. The description does not mention scenarios, limitations, or exclusions. An agent would have no idea whether to prefer this over fomo_token_details for single-token queries or fomo_trading_activity for trade history, and it does not state what 'market data' encompasses.

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, but it only states a query outcome. It does not disclose that this is a read-only lookup, how the friends set is determined, whether it includes the current user, pagination behavior, or any restrictions. It gives no behavioral in every layer of the operation.

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

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

The description is short and contains no padding, presenting its intent front and center. However, it does not have enough content to properly accomplish with its intended purpose; under-specification rather than conciseness is the main concern here.

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 there is no annotations, no output schema, and a nested `tokens` input structure, the description is too thin to fully explain the behavior. It needs to clarify the structure of the token objects and the meaning of 'friends' to be contextually complete.

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

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

The schema has one parameter, `tokens`, but 0% description coverage. The description merely repeats the word 'tokens' without explaining that each item requires `tokenAddress` and `networkId`, or what those fields mean. The agent would have to guess how to construct a valid token object for the intended network.

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 phrase 'Which friends hold which tokens' uses the verb 'hold' and a unique resource ('friends'), clearly distinguishing it from sibling tools like fomo_get_clan_holdings or fomo_get_dev_holdings. It falls short of a 5 because it doesn't specify whose friends are involved or whether the output is grouped by token or friend.

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 usage guidance is provided. The description does not mention when to use this tool versus alternatives, whether it requires a logged-in user's friend graph, has exclusions, or any prerequisite context. The agent must infer the use case from the name and short phrase.

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 full responsibility for behavioral disclosure. It only says it gets token balances, with no mention of read-only guarantees, authentication needs, pagination, result limits, or whether the return is an array or summary. This is a significant gap for a bare get-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?

The description is a single short phrase, 'Token balances for a user', and is absolutely free of filler. It is front-loaded and easy to parse, though the brevity borders on under-specification rather than ideal concision.

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 should give some sense of the expected return (e.g., a list of token holdings with balances), but it leaves that entirely implicit. The tool is simple (one param), but the lack of return type and id semantics means an agent would still be guessing about the actual response 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 only parameter 'id' is a bare string with 0% schema coverage. The description adds that it refers to 'a user', which clarifies the id's purpose but it does not specify whether this is an internal database ID, handle, or address, nor give any format constraints. It adds value but not enough to fully compensate for the schema silence.

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

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

The description states the tool returns 'token balances for a user', specifying a clear resource and target. It is distinct from sibling tools like fomo_get_user_swaps or fomo_get_pnl_equity_series, but it lacks an explicit verb, relying on the tool name's 'get' for action.

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 is given for when to use this tool versus the many related siblings, such as fomo_get_user_swaps, fomo_get_user_rank, or fomo_get_pnl_equity_series. The description provides no exclusions or alternative conditions, leaving the agent to infer the appropriate choice.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that clan details can be windowed ('optionally for a window'), but does not describe what fields are returned, whether the operation is read-only, any permission requirements, or response behavior. This is insufficient for an unannotated 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?

The description is brief and front-loaded, with no filler words. It is under-specified in content but not in structure; every phrase contributes.

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

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

For a tool with no annotations, no output schema, and a required but unexplained id parameter, this description is too sparse. It does not convey what output to expect, what window formats are acceptable beyond '7d', or how this connects to clan-related 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?

Schema description coverage is 0%, so the description must compensate, but it only adds meaning for the optional window parameter via the example '7d'. The required 'id' parameter is undocumented in both the schema and description, leaving the agent without guidance on what identifier to supply.

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 a specific resource ('Clan detail') and an optional time window, making the tool's core purpose clear. It does not explicitly contrast itself with sibling clan tools like fomo_get_clan_leaderboard or fomo_get_clan_holdings, so it falls short of full 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?

No guidance is given on when to choose this tool over sibling tools such as fomo_search_clans or fomo_get_clan_feed. The only conditional information ('optionally for a window') implies a use case but provides no exclusions or alternatives, leaving an agent to infer selection criteria.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Clan activity feed' implies a read-only feed but says nothing about ordering, pagination, time range, authentication, or side effects.

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 very short les, but brevity here is under-specification rather than efficiency. It adds almost no information beyond the tool name and does not front-load any actionable context.

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

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

With no annotations, zero schema coverage for three parameters, and no output schema, the one-line description leaves critical context missing, including what the feed items look like, how pagination works, and what the id parameter refers to.

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?

Input schema coverage is 0%, and the description does not mention the required 'id' or optional 'limit' and 'feedTypes' parameters. An agent cannot infer what values to pass or how they affect the returned feed.

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 'Clan activity feed' is a noun phrase that essentially restates the tool name 'fomo_get_clan_feed' without adding a clear verb or explaining what the feed contains. It only weakly distinguishes this from siblings like get_clan_holdings or get_clan_leaderboard.

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 use this tool, what type of query it suits, or how it differs from sibling feed-related and clan-related tools. The description gives the agent no basis for choosing this tool over alternatives.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals almost nothing: what 'holding' denotes, whether the output is paginated, whether it requires any special context, what the response shape looks like, or whether it reflects current vs historical data. The single phrase answers 'what' but not 'how' or 'what to expect'.

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

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

The six-word phrase is not bloated, but it is severely under-specified rather than efficiently structured. While it front-loads the core idea, the brevity crosses into omission — it functions as a heading, not a specification.

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 3 required parameters, zero schema descriptions, no output schema, and no annotations, this description is entirely insufficient. The agent is left guessing at parameter semantics, return format, and the distinction from closely related clan tools. It does nothing to fill the gaps left by the structured fields.

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 explain the three parameters (id, tokenAddress, networkId), but it explains none of them. An agent cannot determine whether 'id' is a clan id, a holding id, or a user id, nor what tokenAddress/networkId reference. The description adds zero value beyond the raw schema field names.

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 ('breakdown') and resource ('one clan holding') with a clear scope ('per-member'). This meaningfully differentiates it from fomo_get_clan_holdings, which presumably returns whole-clan holdings, and from related tools like fomo_get_balances. However, it doesn't explicitly name the sibling it differs from, relying on inference.

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 use this tool versus fomo_get_clan_holdings, fomo_get_balances, or fomo_get_clan. No conditions, exclusions, or alternative routing are mentioned. An agent must infer the distinction from the tool 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 available, the description carries the full burden of disclosing behavior, but it only states the object of the operation. It does not mention that this is a read-only fetch, what the response looks like, or any limits or side effects. The description does not contradict any annotation, but it also reveals almost nothing beyond the name.

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 extremely short and contains no filler or redundancybuilder. It is front-loaded and easy to parse, but it is so minimal that conciseness is achieved through omission rather than careful editing.

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 parameter descriptions, the tool needs a more informative description to be safely callable by an agent. It omits the meaning of the required id parameter, the behavior of the optional limit, and any indication of what the output contains. This is materially insufficient for a getter tool with multiple 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?

Schema description coverage is 0%, so the description should explain id and limit, but it does neither. The phrase 'of a clan' weakly suggests that id refers to a clan, and limit is left entirely to inference. The description adds little to no parameter-level meaning over the raw 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 phrase 'Token holdings of a clan' identifies the resource but is a noun phrase rather than a stated action, relying on the tool name to supply the 'get' behavior. It is clear what the tool is about, but it does not meaningfully distinguish this from the sibling fomo_get_clan_holding_breakdown, which sounds nearly identical.

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 use this tool, what the id refers to, how limit behaves, or how this relates to the many sibling clan tools. The description does not even explicitly tell the agent to call it to retrieve data; it only names the outcome.

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 must carry the burden of behavioral disclosure, but it only hints that results vary by window. It does not state return format, default window, ordering, pagination, or whether this is a read-only call, though the 'get' verb in the tool name implies safety.

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 extremely terse and front-loaded, with no wasted words. However, it is a noun phrase rather than a structured sentence, and the brevity contributes to under-specification rather than efficient clarity.

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

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

For a two-parameter tool with no annotations, no output schema, and zero parameter documentation, this description is inadequate. An agent cannot determine valid window values, the effect of limit, defaults, or how this differs in usage from related leaderboard tools.

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

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

Schema description coverage is 0%, so the description must compensate. 'By window' weakly implies the window parameter controls the leaderboard period, but no values or formats are provided and the limit parameter is not mentioned at all.

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 phrase 'Clan leaderboard by window' identifies a specific resource (clan leaderboard) and a distinguishing dimension (window), which separates it from siblings like fomo_get_leaderboard and fomo_get_clan. It lacks an explicit verb and does not define what 'window' means, so it is not as complete as a full sentence.

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

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

No guidance is given on when to call this tool versus related clan/leaderboard tools such as fomo_get_leaderboard, fomo_get_clan, or fomo_search_clans. The context is implied by the name only.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but 'App config' reveals nothing about side effects, read-only status, authorization requirements, rate limits, or return format.

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 text is short but not concise in a useful way; it omits essential information without earning its place. This is under-specification rather than conciseness, similar to a single-word placeholder.

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 no output schema and no annotations, the description should explain what data is returned and how the tool fits into the broader API. 'App config' leaves an agent completely in the dark about the tool's outputs and behavior.

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

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

The tool has zero parameters and a schema with no properties, so there is nothing for the description to add about parameter meaning. Per the rubric, zero parameters earns a 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?

The description 'App config' is essentially a noun phrase that restates the resource referenced in the tool name (config). It lacks a verb, action, or any elaboration on what an agent can do with it, so an agent could not determine whether it returns, updates, or validates configuration data.

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

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

The description offers no guidance on when to use this tool versus any of its many siblings. There is no statement of use cases, prerequisites, or conditions under which fomo_get_config should be preferred over other 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 are provided, so the description carries the full burden. It discloses that the result is IDs of followed users, but does not mention pagination, ordering, whether the list is empty-able, rate limits, or any side effects. For a read-only list tool, this is a minimal but not rich behavioral disclosure.

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

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

The description is a single short sentence that is front-loaded with the resource ('Ids of users') and scope ('current account follows'). It is concise and free of filler, though it could be slightly more explicit about the action (e.g., 'Get').

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 tool, the description is mostly adequate: an agent knows what it returns and for whom. However, with no output schema and no annotations, details like response format, pagination, or whether it returns an empty list are missing. It is minimally viable but not complete.

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

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

The tool has zero parameters, so the schema provides no parameter semantics. The description correctly implies the operation is scoped to the current account, which is the only meaningful context. With 0 params, a baseline of 4 is appropriate; the description adds the key semantic (current account scope).

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 ('Ids of users') and a clear scope ('the current account follows'). It is distinguishable from sibling tools like fomo_get_user or fomo_search_users, though it does not explicitly name a sibling alternative. The verb is implied ('get'), but the resource and scope are clear enough.

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

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

The description implies usage: call this when you need the follow list of the current account. It does not explicitly state when not to use it or name alternatives, but the scope ('current account') provides some context. No exclusions or alternative routing 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?

No annotations are provided, so the description carries the full burden. It discloses the window options but doesn't state whether this is a read-only operation, what the leaderboard contains (e.g., rankings by PnL, volume), pagination, or rate limits. The behavior is minimally described.

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

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

The description is extremely short and front-loaded with the resource name. The window values are listed compactly. However, it's so terse that it sacrifices necessary context; still, every word 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 annotations, no output schema, and a single parameter at 0% schema coverage, the description is too thin. An agent doesn't know what the leaderboard ranks (users by what metric?), what the response looks like, or how to choose a window. Sibling tools like fomo_get_user_rank suggest ranking context that is missing here.

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

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

Schema description coverage is 0%, so the description must compensate. It lists the allowed window values (24h, 7d, 30d, all) which adds meaning beyond the bare schema, but it doesn't explain the default behavior when window is omitted, the format expected, or what each window means precisely.

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 'User leaderboard' which identifies the resource, but the verb is implicit (get/fetch). It distinguishes from 'fomo_get_clan_leaderboard' by the 'User' qualifier, though it doesn't explicitly name the sibling. The window values are listed, adding some clarity.

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 tool versus alternatives like fomo_get_user_rank or fomo_get_clan_leaderboard. The window parameter is mentioned but there's no context on typical use cases or exclusions.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It adds one useful detail (timestamp is ISO start-of-window) but does not state read-only behavior, data granularity, ordering, auth requirements, or what the series represents.

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 efficiently short with no filler. The timestamp clarification earns its place. It is not front-loaded with a clear verb phrase, but overall it is appropriately sized for a simple 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 tool with zero annotations and no output schema, the description is insufficiently complete. It fails to explain what the PnL/equity series represents, how it is scoped by userId, or what format the result takes. The only concrete detail is the timestamp format.

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

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

Schema description coverage is 0%, so the description must compensate for both parameters. It only clarifies timestamp format (ISO start-of-window); userId is left entirely unexplained. One of two parameters gains semantics, but the other is completely vague.

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 phrase 'PnL/equity series' identifies the resource but is a fragment rather than a clear verb+resource statement. It is distinguishable from siblings by subject matter, but it doesn't explicitly say it fetches/returns a series for a given user.

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 tool versus siblings like fomo_trading_activity, fomo_get_user_swaps, or fomo_get_balances. The description provides no context for selecting this tool over alternatives.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It conveys that the tool relates to recommended users but does not state whether it returns a list, whether it mutates state, what ordering or criteria are used, or any other behavioral 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?

The description is a single front-loaded phrase with no filler or redundant wording. Every word contributes to the core meaning, making it highly scannable for an agent.

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 tool is low-complexity with one parameter, so a short description is acceptable for basic invocation. However, with no output schema and no annotations, an agent would benefit from explicit mention of the return shape and from guidance distinguishing this from sibling user-related tools.

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

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

With 0% schema description coverage, the description must compensate, and it does clarify that the single 'id' parameter refers to an account. It adds some meaning beyond the raw schema, but it does not explain the id format, required account existence, or how the id relates to a user vs. an account.

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 ('recommended users') and the scope ('for an account'), so an agent can tell that the tool provides account-specific user recommendations. However, it lacks an explicit verb like 'return' or 'get' and does not differentiate itself from sibling tools such as search_users or get_following_ids.

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 implies the tool should be used when recommendations for a given account are needed, which is a recognizable context. It provides no explicit guidance on when not to use it or which alternative tools to prefer, leaving the selection partly to inference.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It hints at a read-like operation ('PnL/equity') but does not state safety, permissions, side effects, whether a user must own the snapshot, or what happens if the snapshot does not exist.

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 only a few words and wastes no space. However, it is closer to a compressed title than a full instruction, and the brevity comes at the cost of missing essential usage and behavioral context.

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

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

For a tool with two required parameters, no output schema, zero schema description coverage, and no annotations, the description is too sparse to let an agent correctly understand the input relationship, expected output shape, or when the tool applies.

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

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

Schema description coverage is 0%, so the description must compensate. It uses 'snapshot id' which maps to snapshotId, but it ignores userId entirely and adds no meaning about how the two parameters relate, what types carry, or how the snapshot is identified.

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 that the tool returns PnL/equity for a given snapshot ID, and 'one snapshot id' differentiates it from the series counterpart. It clearly names the resource and result, even without an explicit verb.

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

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

There is no guidance about when to call this tool versus alternatives. The sibling fomo_get_pnl_equity_series exists and is contextually related, but the description never mentions it or explains when a single-snapshot lookup is appropriate.

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 of disclosing behavior. It only states that the tool returns data; it does not describe the meaning of 'best', any sorting or filtering, authentication needs, error behavior, or side effects.

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 extremely short, but it is under-specified rather than efficiently concise. It omits critical details needed for correct invocation, so the brevity is a deficiency.

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 one-parameter tool, the description still leaves key context unclear, such as what 'id' represents and what the returned trade and comment data looks like. It does not adequately cover the selection or invocation conditions.

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

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

The schema provides no description for 'id' and schema coverage is 0%. The description only loosely implies that the 'id' refers to a user, but it does not explicitly define the ID's semantic meaning or format.

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 indicates the resource ('best trades and comments') and the user scope. The action is implied by the tool name 'get', but it lacks explicit differentiation from similar sibling tools like fomo_get_user_swaps or fomo_get_trade_comments.

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 use this tool versus alternatives. The phrase 'for a user' implies user-scoped usage, but no exclusions or alternative conditions are 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 provided, the description should clarify behavior. It only says 'Single trade with token metadata', giving no information about read-only safety, errors, pagination, rate limits, or whether token metadata is embedded or referenced. The behavioral burden is therefore not met.

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 extremely short and front-loaded with the core return value ('a single trade'). There is no filler or repetition of the tool name, though the noun-phrase style omits an explicit action verb.

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

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

With no annotations and no output schema, an agent gets very little context: no response format, no definition of the id, no error behavior, and no detail on what 'token metadata' includes. This is insufficient for confident invocation, especially given the large sibling tool set.

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 explain the id parameter. It does not explicitly say what the id refers to, what format it takes, or where it comes from; the phrase 'single trade' only weakly implies that the parameter identifies a trade.

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 a specific resource ('Single trade') and indicates it includes token metadata, which distinguishes it from sibling list operation fomo_get_trades. It still lacks an explicit verb like 'retrieves' or 'returns', so it falls just short of a top score.

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 guidance on when to prefer this tool over alternatives such as fomo_get_trades or fomo_get_trade_comments. There is no mention of prerequisites, context, or routing cues, so an agent must infer usage solely from the name.

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 must carry the full burden. The only behavioral trait disclosed is pagination via lastCommentId. It does not state whether the operation is read-only, describe the response format, or mention any constraints like maximum page size or ordering. For a simple get-comments tool, this is minimal but insufficient given 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?

The description is concise and front-loaded with the main purpose and pagination mechanism. However, it is under-specified rather than concise in a helpful way—it omits necessary context. A 3 reflects that it is short but not optimally structured for an agent to act reliably.

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 no annotations, no output schema, and minimal parameter descriptions, the definition is incomplete. An agent cannot determine what the tool returns, how to handle pagination boundaries, or any side effects. While simple, it lacks essential operational details to be considered 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?

Schema description coverage is 0%, so the description must explain parameters. It mentions lastCommentId as a paging cursor but does not define it further (e.g., format, meaning). tradeId is only implied as the trade identifier, with no elaboration on its purpose or required format. The description adds very little semantic value beyond the schema 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?

Clear verb+resource: retrieves comments for a trade. The phrase 'Comments on a trade' is specific, but it does not differentiate from siblings like fomo_get_trade (which likely returns the trade itself) or fomo_get_trades (list of trades). A 4 is appropriate because it states the core action but lacks distinguishing context.

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 tool versus alternatives. The description does not mention conditions, prerequisites, or when to prefer other tools. It relies entirely on the tool name to imply use case, which is inadequate.

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 of behavioral disclosure. It reveals that the tool is a filterable trade lookup, but does not mention pagination, sort direction, date ranges, output shape, or whether no parameters returns all trades. 'Filterable' is the only behavioral hint.

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 very short and front-loads the key filters with no wasted words. It sacrifices clarity for brevity, especially around 'close order', but it earns its place as a compact summary.

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?

This is a simple list tool with no output schema, no annotations, and all optional parameters, but the description still leaves important gaps: no default behavior, no return-value information, and no indication of how the filters interact. It is enough to recognize the tool, but not enough to invoke it confidently in a complex decision.

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

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

Schema coverage is 0%, so the description needed to compensate by explaining the parameters. It maps userId to 'user' and tokenAddress to 'token' fairly clearly, but 'close order' for orderBy is ambiguous: it could mean sorting criteria, closed order status, or a specific field value. The description does not resolve what orderBy values look like.

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 (trades) and the three filter dimensions (user, close order, token), which matches the tool's name and distinguishes it from the singular fomo_get_trade. It is not a tautology, though it could be more specific about what kind of trades and what the response represents.

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 use this tool versus nearby alternatives like fomo_get_trade, fomo_trading_activity, or fomo_get_user_swaps. The phrase 'filterable by user, close order and token' implies a search/list use case, but no explicit context or exclusions are provided.

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 of behavioral disclosure. It only states that a user is fetched by id; it does not mention read-only behavior, authentication requirements, error behavior, or what is returned. The word 'Get' implies a read, but that is minimal.

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 efficient sentence with no redundancy. It front-loads the action and resource and conveys the essential lookup parameter clearly.

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

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

For a simple single-parameter fetch, the description provides enough to know what resource is being retrieved and by what key. However, there is no output schema, no annotation, and no guidance on response shape, error cases, or when to choose a sibling tool, so completeness is only 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?

The schema has one required string parameter named 'id' with 0% description coverage. The description repeats that the user is found 'by id' but adds no additional meaning about the id format, origin, or constraints beyond what the schema already shows.

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

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

The description clearly states the action ('Get') and the resource ('a fomo.family user'), and specifies the lookup mechanism ('by id'), which implies differentiation from the sibling fomo_get_user_by_handle. However, it does not explicitly name or contrast that sibling, so it stops just short of full 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?

No guidance is provided about when to prefer this tool over alternatives such as fomo_get_user_by_handle or fomo_search_users. There is no stated condition, prerequisite, or exclusion, leaving the agent to infer usage solely from the tool name.

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 of behavioral disclosure. It only states the operation and does not disclose what the response contains, whether the handle is case-sensitive, whether it returns null/error for unknown handles, or any rate-limit/auth requirements. For a simple lookup tool this is a moderate gap, but with zero annotations the description should add more 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?

The description is a single, front-loaded sentence with no wasted words. It states the action and the lookup key efficiently. It could earn a 5 by adding a brief usage note, but as-is it is appropriately concise.

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 lookup tool with no output schema and no annotations, the description is minimal. An agent knows what to pass but not what to expect back, how errors are signaled, or how this differs from fomo_get_user. Given the sibling list includes fomo_get_user and fomo_search_users, the description should clarify the distinction to avoid mis-selection.

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

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

Schema description coverage is 0%, so the description must compensate. It names the parameter 'handle' in the description ('by handle'), which adds a little meaning beyond the schema's bare string type. However, it does not specify the expected format (e.g., exact handle, case sensitivity, whether it includes the @ prefix). Baseline 3 is appropriate because the description at least identifies the key parameter's role.

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 'Get a fomo.family user by handle' clearly states the verb (get), the resource (a fomo.family user), and the lookup key (handle). It distinguishes itself from siblings like fomo_get_user (which likely fetches by a different identifier) and fomo_search_users (which implies query-based search), though it doesn't explicitly name those alternatives.

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

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

The description implies usage: call this when you have a handle and need a single user. It does not explicitly state when not to use it or mention alternatives like fomo_get_user or fomo_search_users. The context is clear enough for an agent to infer the primary use case, but there is no explicit routing guidance.

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

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

No annotations are present, so the description bears full responsibility for behavioral context. It implies a read operation but does not disclose what 'rank cut' means, the return shape, or any side effects, rate limits, or auth requirements.

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, efficient line with no filler or redundant wording. It packs the resource, scope, and time periods into a compact phrase, which is good for an agent glance.

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

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

Given the one parameter and no output schema, the description is incomplete: it leaves 'rank cut' undefined and does not clarify what the returned data will look like. The time frames are listed, but the meaning of the result and the expected id format are missing.

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

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

The description does not explain the 'id' parameter beyond the implicit 'for a user'. With schema description coverage at 0%, the description should clearly state that 'id' refers to a user identifier, but it does not, leaving the parameter semantics mostly to inference.

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 user's leaderboard rank across time periods, and implies a retrieval action. It differentiates itself from the broader fomo_get_leaderboard sibling by focusing on a single user, though the term 'rank cut' is 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?

No explicit guidance is given about when to choose this tool over alternatives like fomo_get_leaderboard or fomo_get_user. The phrase 'for a user' gives a clue it is user-scoped, but no exclusions, prerequisites, or comparison to siblings are provided.

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 must carry behavioral context. It implies a read-only lookup and mentions optional filtering, but it does not disclose response format, pagination, or error behavior. This is minimal but not misleading.

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

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

The description is a single concise sentence that front-loads the main purpose and then adds the optional filter. Every word contributes meaning.

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

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

For a two-parameter, no-output-schema tool, this is adequate for an agent to understand the operation, but the ambiguous id semantics and lack of any return-shape or pagination hints leave notable gaps. It is usable 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 description maps id to a user and tokenAddress to an optional token filter, adding meaning beyond the bare schema. It does not clarify whether id is a handle, internal ID, or address, and gives no format details for tokenAddress, so compensation for the 0% schema coverage is partial.

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 ('swap history for a user') and the optional filter ('one token'). It is not a tautology and is distinguishable from user-profile siblings, though it does not explicitly contrast with fomo_get_trades or fomo_trading_activity.

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 optional-filter clause gives some usage context for the tokenAddress parameter. However, it provides no explicit guidance on when to prefer this tool over related siblings, nor any exclusions 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 behavioral disclosure burden. 'Current watchlist' only names the data and does not disclose authentication expectations, whose watchlist is returned, what items it contains, ordering, pagination, or response shape. The read-only nature is implied by the tool name rather than stated.

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 extremely short and contains no filler, but it is under-specified: a two-word noun fragment is not an adequate tool description. Conciseness is achieved at the cost of omitting useful action and context 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 tool with no output schema, no annotations, and a minimal description, important context is missing: what a watchlist contains, whether it is user-specific, and what the returned data looks like. The sibling list hints at watchlist operations but does not compensate for the lack of description detail.

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 has zero parameters, so there is no parameter ambiguity for the description to resolve. The zero-parameter baseline of 4 applies, and the description does not need to compensate for missing schema 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?

The phrase 'Current watchlist' identifies the resource but lacks a verb, so the action must be inferred from the tool name 'fomo_get_watchlist'. It is minimally clear and 'current' adds a small semantic distinction, but it does not explicitly differentiate itself from add/remove watchlist siblings beyond what the name already implies.

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 is given about when to use this tool versus fomo_add_watchlist, fomo_remove_watchlist, or any other sibling. There is no mention that this is a read-only retrieval or that it should be used to inspect the current state before modifying it. The agent must infer usage entirely from tool names.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior, but it only says 'Candles'. It does not state whether this is a read-only fetch, what data shape is returned, what time ranges are available, or how 'period' values are interpreted. Some behavior is implied, but not enough for an agent to know what will happen when the tool is invoked.

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 extremely short, which makes it concise in word count, but it is under-specified rather than efficiently structured. It front-loads 'Candles' without grounding it in a clear operation, and the two fragments do not form a complete or useful definition for the tool. Every word is economical, but the content is insufficient for the tool's complexity.

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

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

Given the absence of annotations, an output schema, and any parameter descriptions, the description should provide a much more complete picture. It only hints at chain and period formats and omits the required address parameter, return behavior, and usage context. An agent would not be able to call this tool reliably without additional inference or external knowledge.

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 examples 'chain like evm:4663' and 'period like 1m' add useful format meaning that the bare string schemas do not provide. However, the required 'address' parameter is entirely absent from the description, and no valid period values or chain formats are fully enumerated. The description partially compensates for the 0% schema coverage but leaves important gaps.

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

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

The description states the tool deals with 'Candles', which combined with the tool name 'fomo_ohlcv' implies it fetches OHLCV/candlestick data. However, it lacks a clear verb and resource construction (e.g., 'Gets OHLCV candles for an address'), and the required 'address' parameter is not mentioned at all. It is understandable but vague, and it does not explicitly differentiate from sibling tools.

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

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

There is no guidance about when to use this tool versus the many sibling tools, such as fomo_token_details or fomo_trading_activity. The only usable guidance is the format hints for 'chain' and 'period', but these are parameter examples rather than usage context. This leaves the agent to infer the appropriate scenario.

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 for behavioral disclosure. The description only states a mutation occurs, but does not explain side effects, whether removal is reversible, auth requirements, or handling of already-absent tokens.

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 one succinct sentence with no redundant words. It immediately conveys the action and target, making it easily scannable for an agent.

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 required parameters and no output schema, the description omits critical operational details: what networkId indicates, the expected response format, error conditions, and whether the token must already exist in the watchlist. This leaves an agent guessing about correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It interprets token as 'token from the watchlist' but does not explain the role of networkId or clarify that tokenAddress is the token identifier. The description adds minimal value over the parameter property names.

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 tool description states a specific verb ('Remove') and resource ('token from the watchlist'). This clearly distinguishes it from sibling tools like fomo_add_watchlist and fomo_get_watchlist through the verb and direction of operation.

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 provides no guidance on when to call this tool versus its siblings (add/get watchlist). It lacks context on prerequisites, expected state (e.g., token being currently watched), or trade-offs with alternatives.

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

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

With no annotations, the description carries the behavioral burden. It usefully clarifies that this is a quote (not an execution) and defines token ID format and amount units, but it does not mention response shape, whether the quote is indicative/expiring, or any auth/rate-limit 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?

Two short sentences, front-loaded with the main action; no filler. The format note earns its place.

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

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

For a simple three-parameter quote tool, the description covers the essential call semantics. However, with no output schema and no annotation, it leaves the agent to infer the shape and validity of the returned quote and any execution-related caveats.

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

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

Schema coverage is 0%, but the description compensates by defining the format for inTokenId/outTokenId ('<mint>:<chainId>') and the unit for amount ('base units'). It does not give examples or clarify decimal handling, but the core semantics are present.

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

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

The description states a specific action ('Quote a swap') on a clear resource, and it adds the token ID format to disambiguate the input convention. It stands apart from the sibling getters/search tools, though no other swap tool exists to compare 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?

No explicit when-to-use or when-not-to-use guidance is given, and no alternatives are named. The use case is only implied by the name and 'Quote a swap', so an agent must infer that this is for obtaining swap quotes rather than executing them.

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 of behavioral disclosure. It only states 'Search clans by term,' which implicitly suggests a read operation but offers no details about return format, pagination, rate limits, or potential side effects. This is a critical gap for a 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?

The description is a single, terse sentence with no redundancy, achieving conciseness and front-loading the action and resource. While it is structurally tight, the brevity results in under-specification, but that is more a content completeness issue than a conciseness flaw.

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 one required parameter and no output schema or annotations, the description must at least indicate the return type (e.g., a list of clan summaries) and any constraints. This description provides none, so an agent cannot reliably know what to expect when 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 has zero description coverage, and the description adds no information about the 'searchTerm' parameter beyond the word 'term.' It does not explain matching rules (e.g., exact vs. partial), case sensitivity, wildcard support, or any accepted formats. The agent is left entirely to infer from the parameter name.

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

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

The description uses the verb 'search' and the resource 'clans,' clearly stating the tool's core action. However, it does not differentiate this from sibling search tools like fomo_search_users or fomo_search_tokens beyond the resource name, leaving some ambiguity in a list with many similar search alternatives.

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

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

No guidance is provided on when to use this tool versus alternatives such as fomo_get_clan, fomo_get_clan_leaderboard, or fomo_search_users. There is no mention of search scope, result type, or conditions that would make this tool preferable over others.

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 of behavioral disclosure. It only says 'search tokens by phrase' without revealing whether the search is case-insensitive, returns partial matches, or has a limit on results. An agent cannot anticipate response size or matching 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 description is minimally sized and front-loaded; the single sentence conveys the core action with no filler. However, it could be more informative without much added length, so it is concise but not under-specified enough to be penalized heavily.

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

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

Given the lack of annotations and output schema, the description is incomplete. It fails to clarify the search semantics, potential result structure, or any usage constraints. An agent may struggle to interpret the response or to form an effective query.

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

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

Schema description coverage is 0%, so the description must compensate for the single parameter 'phrase'. The description only repeats the parameter's name without adding semantics (e.g., format, length limits, example values). It does not clarify whether 'phrase' should be a token symbol or a natural-language phrase.

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 clear verb and resource: 'Search tokens by phrase'. It distinguishes from 'fomo_search_users' and 'fomo_search_clans', which search other entities, but there is no mention of the result scope or filtering; it is generic but not misleading.

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 tool versus alternatives like 'fomo_filter_tokens' or 'fomo_search_users'. It does not specify what kind of phrase is expected (e.g., exact token name, symbol, partial match) or whether to prefer another tool for broader search.

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 term 'fuzzy-search' discloses inexact-match behavior, which is a meaningful behavioral trait. However, with no annotations, the description carries the full burden and still omits output shape, result limits, and whether matching is by handle, display name, or other fields.

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

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

The description is a single compact phrase with no filler and the key verb is front-loaded. Every word earns its place.

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

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

For a single-parameter search tool, the description is almost sufficient, but it lacks any indication of the expected return value, pagination, or match scope. Without an output schema, the agent must guess what a successful search result looks like.

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 only says 'by term', which adds minimal meaning beyond the property name 'searchTerm'. It does not explain format, length requirements, case sensitivity, or which user fields are searched.

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

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

The description names a specific verb, 'Fuzzy-search', a specific resource, 'users', and the input, 'by term'. It clearly distinguishes this from sibling exact-lookup tools like fomo_get_user_by_handle and fomo_get_user.

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 explicit statement about when to use this tool versus alternatives, but the word 'fuzzy' implies it is for partial or inexact matches. The agent must infer from sibling names rather than receiving direct routing guidance.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior, but it only states a static property ('Tokens supported for transfers') with no indication of side effects, output nature, or operational behavior. It does not even explicitly say whether calling the tool returns a list or performs a check. This is insufficient for a zero-annotation 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?

The description is extremely short at four words, which is suitably concise for a zero-parameter tool. However, it is a fragment rather than a complete sentence, and it largely duplicates the tool name, slightly reducing its structural value. It is not bloated, so it earns a 4.

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 tool has no parameters, making invocation trivial, but there is no output schema and no description of what the returned data looks like. Given the large sibling set, an agent cannot infer whether this returns a static list, a set of token details, or something else. The description is too minimal to be contextually complete for an agent that needs to interpret results.

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 there are zero parameters to describe. Per the rubric, a 0-parameter tool receives a baseline of 4. The description adds nothing about parameters, but no parameter documentation is needed because none 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?

The description 'Tokens supported for transfers' is a noun phrase without a verb, so the agent cannot tell whether the tool lists tokens, validates support, or retrieves a configuration. It essentially paraphrases the tool name (supported_transfer_tokens), making it close to a tautology. It also does not distinguish this from siblings like fomo_transfers_with or fomo_token_allow_list.

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 fomo_token_allow_list, fomo_verified_tokens, or fomo_transfers_with. The description offers no context, prerequisites, or exclusions. An agent receives zero guidance on selecting this over sibling tools.

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

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

With no annotations and no output schema, the description carries the full burden of behavioral disclosure. It only states that the tool provides a 'detailed token allowlist,' but does not reveal whether it is a read-only operation, what format the allowlist takes, whether it requires authentication, pagination, or any side effects. This is heavily insufficient for an agent to predict tool 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 description is extremely brief (two words), but this brevity is under-specification rather than effective conciseness. It adds little information beyond the tool name and does not earn its place because it merely restates the purpose in vague terms. A useful description would require at least a full sentence explaining the tool's function.

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 tool is extremely simple (no parameters, no output schema), but the description still fails to convey what the allowlist contains, how it relates to other token tools, or what an agent should expect as a response. Given the many sibling tools with similar token-list purposes, this description leaves the tool's role ambiguous and 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 and the schema is empty, so schema description coverage is trivially 100%. The description does not need to explain parameter semantics because there are none. The baseline for zero parameter tools is 4, and no further clarification is required.

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

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

The description 'Detailed token allowlist' is essentially a restatement of the tool name with the adjective 'detailed' added. It lacks a verb or action, so it does not convey what the tool actually does (e.g., retrieves, lists, validates). It also does not differentiate this tool from siblings like fomo_supported_transfer_tokens or fomo_verified_tokens, which likely also return lists of allowed or verified tokens.

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 provides no guidance on when to use this tool versus alternative token-related tools. There is no mention of use cases, conditions, or exclusions. An agent would have to guess based on the name alone, making selection unreliable.

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 present, so the description carries the full behavioral burden. It states what metrics are returned, but it does not explicitly say the operation is read-only, describe response structure or units, clarify whether 'holders' means a count or a list, or mention any rate limits or errors.

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

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

The description is a single compact phrase with no redundant words and the key resource ('a token id') appears at the end. It could be improved by adding a verb and sentence structure, but it is appropriately short.

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 one-parameter read tool with no output schema, the description provides a minimal but viable summary of the expected return content. It is missing ambiguity resolution ('volumes' over what period? 'holders' count or list?), but it is not severely incomplete for a simple endpoint.

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

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

Schema coverage is 0% and the description merely restates that the parameter is a token id, which the schema property 'tokenId' already conveys. It adds no detail about the identifier's format, token standard, or domain, so an agent gains little parameter meaning beyond the input 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 a specific resource (a token id) and lists the exact data returned: buy/sell counts, volumes, and holders. This is clear enough to distinguish the endpoint from general token search/filter tools, though it does not explicitly name a sibling 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?

The phrase 'for a token id' implies the tool is used when you need market/activity metrics for a known token identifier. It provides no explicit comparison with siblings such as fomo_trading_activity or fomo_top_holders, nor any when-not-to-use guidance, so usage is only inferred.

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

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

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It does not state whether the tool is read-only or mutating, what side effects occur, what the return value is, or any other behavioral traits. The verb 'swap' hints at modification but lacks detail.

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 short, but it is under-specified rather than concise. A few words that convey no useful information do not 'earn their place'. The structure provides no front-loaded key details and fails to communicate anything actionable.

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

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

For a tool with 5 parameters, no schema descriptions, no output schema, and no annotations, this description is grossly incomplete. An agent cannot infer the operation's meaning, parameter purposes, or expected results, making it impossible to 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?

Schema description coverage is 0%, and the description does not explain any of the five parameters (tokenAddress, networkId, limit, threshold, excludeThesis). Even required parameters are undefined. The description adds no semantic meaning beyond the raw 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 'Swap feed for a token' is a fragment, not a clear statement of purpose. It uses a generic verb 'swap' and ambiguous nouns without specifying what operation is performed, what the feed is, or what the output is. It doesn't differentiate from sibling tools that also deal with token data or feeds.

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 provides no guidance on when to use this tool versus alternatives. There is no mention of context, prerequisites, or exclusions. The agent is left without any basis to decide whether this tool applies.

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 for behavioral disclosure. It only hints at a time-paging mechanism, but does not disclose whether the operation is read-only, how paging interacts with beforeTime/afterTime, what order results are returned in, or any side effects. This is minimal, non-misleading but insufficient 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 only four words, so it is not wordy, but this is under-specification rather than conciseness. It lacks a subject-verb structure and omits critical information, so the brevity does not serve the agent.

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

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

For a tool with 6 parameters, 2 required, no output schema, and no annotations, this description is far from complete. It fails to explain the time-paging semantics, the token/network requirement, or what 'sorted' means, leaving the agent without enough context to invoke the tool correctly.

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

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

Schema description coverage is 0% and the description provides zero explanation of the six parameters (tokenAddress, networkId, limit, threshold, beforeTime, afterTime). An agent cannot infer what 'threshold' means or how the time parameters behave, and the description does not compensate for the schema's lack of descriptions.

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 is a noun phrase with no explicit verb: 'Thesis posts with time paging.' It does not say whether the tool fetches, lists, or creates thesis posts, and it does not clarify what 'sorted' means relative to the sibling tool fomo_token_thesis. This is close to a tautology of the tool name.

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 is provided about when to use this tool versus fomo_token_thesis, fomo_token_feed, or any other sibling. The description does not mention scenarios, prerequisites, or alternatives, leaving the agent to guess the appropriate context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state whether this is a read-only operation, what inputs trigger side effects, what the output contains, or any other behavioral trait.

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 extremely short, but this is under-specification rather than effective conciseness. It is a fragment with no sentence structure, no front-loaded actionable information, and no explanation of what the tool actually does.

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 four undocumented parameters, no annotations, and no output schema, the description is completely inadequate. An agent cannot determine prerequisites, expected inputs, return values, or how this tool differs from fomo_token_sorted_thesis.

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 explain any of the four parameters. tokenAddress, networkId, limit, and threshold are entirely undocumented in prose, making it impossible to know how to populate them 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 'Thesis posts for a token' is essentially a restatement of the tool name and lacks a verb or action. It does not clearly say what operation the tool performs, nor does it differentiate from the sibling fomo_token_sorted_thesis.

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 use this tool versus any sibling, such as fomo_token_details or fomo_token_sorted_thesis. The description provides no context for choosing this tool over alternatives.

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

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

No annotations are present, so the description carries the full behavioral burden. It does name the output categories (allowlist and buy-sell flags), but it does not explain the flag values, return format, network handling, or failure behavior. This leaves key operational details implicit.

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 short, front-loaded phrase with no filler words. It is concise, but the brevity borders on under-specification, which is penalized in other dimensions rather than here.

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

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

With no output schema, no annotations, and two required parameters, the description should at least define what the flags mean and how networkId/tokenAddress are used. It does neither, and it also fails to clarify its relationship to the similarly named fomo_token_allow_list sibling.

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 only says 'for a token' without explaining tokenAddress format or the meaning/role of networkId. While the parameter names are somewhat self-explanatory, the description does not compensate for the missing schema-level 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?

The description identifies the resource (a token) and the two output concepts (allowlist and buy-sell flags), but it lacks an explicit verb and does not distinguish this tool from fomo_token_allow_list, which likely overlaps with the allowlist portion. It is clearer than a tautology but still vague about what 'warnings' actually represent.

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 about when to use this tool versus fomo_token_allow_list, fomo_token_details, or fomo_filter_tokens. No alternatives, prerequisites, or exclusions are mentioned, so the agent must infer usage entirely from the name and sibling list.

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?

There are no annotations, and the description only states 'Top holders for a list of tokens.' It does not disclose whether this is a read-only query, how results are ordered, whether pagination or limits apply, or any other behavioral traits. With no annotations, the description carries the full burden and fails to provide meaningful transparency.

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

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

The description is a single concise phrase with no redundant filler. It is front-loaded with the main concept, though the brevity comes at the expense of completeness.

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 that there are many fomo sibling tools, the description fails to provide any context about output semantics, token address formats, supported networks, or how it relates to get_balances, get_holders, or other similar tools. The absence of annotations and output schema makes the description inadequately contextual.

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 says 'list of tokens,' which roughly maps to the 'tokens' parameter, but it does not explain the nested tokenAddress and networkId properties that the schema requires. With schema description coverage at 0%, the description needed to compensate but did not.

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 'Top holders for a list of tokens' identifies the resource (top holders) and the input (a list of tokens), but it lacks a verb and does not differentiate this tool from other holder-related siblings like fomo_dev_holdings and fomo_friends_holdings. The purpose is somewhat clear but not precisely specified.

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 is provided on when to use this tool versus alternative holder or token analysis tools. It does not specify intended scenarios, limitations, or exclusions, leaving the agent to infer use cases from the name and 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?

No annotations are provided, so the description must carry the behavioral burden. It only says 'feed,' giving a weak sense of a stream/list, but it does not disclose ordering, pagination, time window, or whether it is read-only. There is no contradiction with annotations, but there is also almost no behavioral disclosure.

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

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

The definition is very short, which is fine, but it is under-specified rather than appropriately concise. It consists of a single noun phrase and does not structure information about behavior, parameters, or usage that 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 2 undocumented parameters, no output schema, no annotations, and many sibling feed tools, this description is insufficient for correct invocation. An agent cannot tell what the response looks like, what threshold filters, or how this differs from other feed endpoints.

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 compensate. 'limit' may be inferable as a count, but 'threshold' is entirely ambiguous—threshold for what? No units, defaults, or filtering semantics are provided.

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 a global trading activity feed, which adds a scope qualifier, but it lacks a verb and does not state what the feed contains (trades, swaps, transactions). It is not a tautology because 'global' adds some distinction, but it remains vague about the exact resource being returned.

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 use this tool versus siblings like fomo_get_trades, fomo_token_feed, or fomo_get_clan_feed. The word 'global' implies a broad use case, but the description never states conditions, exclusions, or alternatives.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses nothing about whether the operation is read-only or mutating, what the response contains, pagination, or whether user context is required.

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 only five words and contains no redundancy, but it is under-specified rather than appropriately concise. It does not earn its place because it provides almost no useful information beyond the tool 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?

With one parameter, no annotations, no output schema, and a fragment of a description, the tool is not adequately described. An agent has no way to know the expected input semantics, return value, or side effects.

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

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

Schema coverage is 0%, and the schema only says userId is a required string. The phrase 'another user' suggests userId identifies the other party, but it does not clarify ID format, whose perspective is used, or whether this is the counterparty or the subject.

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 'Transfers with another user' is essentially a restatement of the tool name. It lacks an explicit verb such as 'get', 'list', 'send', or 'execute', so an agent cannot tell whether this returns transfer history or performs a transfer.

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 use this tool, what prerequisites apply, or how it differs from sibling tools like fomo_supported_transfer_tokens or fomo_trading_activity. No alternatives or exclusions are mentioned.

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 present, so the description bears full responsibility for disclosing behavior. 'Verified token list' conveys only that some list is retrievable; it says nothing about filtering, sorting, pagination, authorization, or what 'verified' means.

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 bare noun phrase that essentially restates the tool 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?

A zero-parameter tool with no annotations and no output schema needs the description to explain what is returned and how this differs from siblings like fomo_token_feed, fomo_token_allow_list, or fomo_filter_tokens. The two-word description provides none of this.

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

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

There are zero parameters, so there is nothing the description must explain beyond the schema. The baseline of 4 applies. However, the description still doesn't explain the shape of the returned list, which slightly reduces its value.

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 is a noun phrase ('Verified token list') that essentially restates the tool name without specifying an action. It implies retrieval of a list but does not use a clear verb or define the resource precisely. It also fails to distinguish this from several token-related siblings like fomo_filter_tokens, fomo_search_tokens, fomo_token_feed, or fomo_token_allow_list.

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 is given on when to use this tool versus alternatives such as fomo_token_feed, fomo_token_allow_list, or fomo_search_tokens. There is no mention of whether this returns all verified tokens, a paginated list, or how it differs from similar tools.

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