Lagos Life by Nova (CIVAI)

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

There are no annotations, so the description must carry the full behavioral burden. It reveals that this is a PUT /api/save mutation and recommends previewing first, but it omits permissions, irreversibility, spending effects, selling consequences, and failure behavior.

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

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

The description is front-loaded and has no wasted words. Its brevity is a weakness for such a complex tool, but the structure itself is clean and efficient.

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

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

For an eight-parameter mutation with no annotations and no output schema, the description is too thin. It does not cover parameter formats, side effects, permissions, or how buy/sell/move/stow operations interact.

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 only 25%, and the description does not explain the JSON structures, required combinations, max spend behavior, or how the eight parameters map to the listed operations. It names operation categories but leaves most parameter semantics undocumented.

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

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

The description gives a specific verb and resource ('Apply home changes') and enumerates the supported operations (add/buy, layout, move, stow, sell). It does not explicitly distinguish itself from sibling tools like propose_home_design or preview_home_design, so it falls short of a 5.

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

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

It gives a concrete prerequisite: preview with emit_display using pipeline_name apply_home_design first. However, it does not address when to use this instead of propose_home_design or preview_home_design, and it provides no 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 provided, the description carries the full burden. It adds meaningful behavioral context such as the POST endpoint, password requirement, and that many 'announcement*' names are taken or reserved, but it does not disclose side effects, reversibility, or failure behavior for this mutation.

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

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

Three short sentences, front-loaded with the primary action and then the key constraints. No filler; every sentence adds practical 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 mutation tool with no annotations, no output schema, and partial schema coverage, the definition is adequate but incomplete. It covers authentication and naming pitfalls, but leaves the agent guessing about return values, side effects, and the exact role of every parameter.

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 only 50%, so the description should compensate. It clarifies that the password is the current password and implies the signed-in account context, but it does not explain the 'lagoslife_username' parameter or the 'notification_message' fallback behavior.

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

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

The description states a specific verb and resource ('Rename the signed-in Lagos Life account') and even names the endpoint. It clearly distinguishes this from account-creation or login siblings by emphasizing the signed-in account 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?

It gives useful usage context: current password is required, and it points users to 'register' when they want an available name instead. It does not exhaustively contrast every alternative, but the key routing guidance is present.

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

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

With no annotations, the description carries the full behavioral burden and does well: it discloses the mutation, the default amount, the per-call cap, and the STALE_SAVE failure mode with recovery steps. It does not discuss reversibility or permissions beyond the login prerequisite.

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

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

The description is front-loaded with purpose, then moves through prerequisites, defaults, error handling, and success reporting. It is dense but largely purposeful, with minor implementation details like the endpoint path and POC filename taking up space.

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

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

For a two-parameter mutation tool with no annotations or output schema, the description is mostly complete: it covers prerequisites, amount defaults and caps, stale-state recovery, and what to report after success. A little more detail on failure modes or side effects would make it fully sufficient.

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

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

Schema description coverage is 100%, so the parameters are already documented. The description repeats the default and cap for wallet_inflate_amount_ngn but adds little about notification_message beyond what the schema says, making the baseline 3 appropriate.

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

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

The description gives a specific verb and resource: add in-game naira via a wallet top-up endpoint. It is clear what the tool does, though it does not explicitly distinguish itself from related siblings such as send_money or get_wallet_and_job.

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

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

It gives clear prerequisites: call session_status first, and route through emit_display/input if not signed in. It also provides recovery guidance for STALE_SAVE, but does not explicitly state when to prefer this tool over alternatives like send_money.

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

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

With no annotations, the description carries the full behavioral burden, and it discloses almost nothing. 'Open' hints at a possible side effect (marking the thread as read, creating a thread if none exists) but this is never clarified, nor is pagination, message history depth, or auth requirements. Only the read intent is conveyed.

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

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

A single front-loaded sentence with zero filler. It is efficient, though its brevity is part of why other dimensions are thin rather than a sign of rich structuring.

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 simple (2 params, no output schema) but has no annotations, so the description should have covered whether this opens a new thread, marks messages read, and how much history returns. For a bare read tool it is adequate, but the side-effect question an agent would have is left open.

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

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

Schema coverage is 100%, so both parameters are already documented in the schema, including the unusual notification_message fallback wording. The description adds no additional meaning about either parameter, which is the expected baseline when the schema does the heavy lifting.

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

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

States a specific verb and resource: open one private chat and read the back-and-forth messages with another player. The singular 'one private chat' implicitly contrasts with the plural listing tool, but it never names list_dm_threads, so the sibling differentiation is left to 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?

Usage is only implied: you call this when you already know which player's conversation you want. There is no explicit statement of when to prefer this over list_dm_threads or send_dm, and no prerequisites (e.g. must the chat already exist?) 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 behavioral burden. It implies a read operation but does not state permissions, privacy constraints, read-only behavior, or what the response looks like, leaving significant gaps for a record-access 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 front-loaded sentence with no wasted words. It could be slightly more precise about scope, but 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 simple one-parameter read tool, the description identifies the record types being checked. However, with no annotations and no output schema, it should do more to explain access scope or behavior, so it is only minimally complete.

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

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

Schema description coverage is 100%, so the single parameter is fully documented in the schema. The description does not add any meaning about notification_message, so the baseline 3 is appropriate.

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

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

The description uses a specific verb ('Check') and concrete resources ('clean record, EFCC file, or police history'), making the tool's purpose clear. It does not explicitly distinguish itself from nearby siblings such as report_to_police or get_my_profile, so it stops short of a 5.

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

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

The phrase 'your clean record' implies the tool is for checking one's own record, but there is no explicit guidance on when to use it instead of alternatives, nor any when-not conditions. Usage is inferable but not spelled out.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only view through "See," but does not state whether rewards are claimed, whether the call has side effects, what permissions are needed, or what the response contains.

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 filler. Every word contributes to stating what is returned and for whom.

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

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

For a simple getter with one fully documented optional parameter and no output schema, the description states the returned data clearly enough. It could be more complete by clarifying whether the rewards are merely viewed or also claimed, but the core context is present.

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

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

There is one optional parameter and schema description coverage is 100%, so the schema already fully documents notification_message. The description adds no parameter-level meaning beyond that, which is the baseline expectation when the schema is complete.

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

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

The description uses a specific verb ("See") and names the exact resource ("today’s daily login rewards and streak") plus the scope ("for your sim"). It is clear what the tool returns, though it does not explicitly differentiate itself from any sibling because no sibling covers daily rewards.

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 when-to-use or when-not-to-use guidance and names no alternatives. The phrase "today’s" implies a daily check-in context, but the agent must infer that usage entirely.

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 burden. It discloses the GET/read nature and a downstream confirmation workflow, but it does not explain errors, permissions, or what the fetched layout contains.

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

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

The description is two compact sentences with the main action front-loaded and no wasted text. The endpoint and follow-up application note are both relevant.

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 simple, and the description gives the core action plus a downstream application hint. However, with no output schema and no annotations, it should do more to explain the returned layout or how an agent obtains/validates the required job id.

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 only 50%. The description does not explain the required decorator_job_id at all, and the notification_message meaning comes only from the schema. The mention of home_design_layout_json is a downstream usage note, not parameter guidance.

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

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

The description states a specific verb and resource: 'Fetch a decorator job layout', and includes the backing endpoint. It is clear enough to distinguish from generic layout tools, but it does not explicitly contrast itself with siblings such as get_home_layout.

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 the tool is used before applying a design via home_design_layout_json and notes that user confirmation should happen first. However, it does not clearly say when to choose this over get_home_layout or where decorator_job_id should come from.

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

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

With no annotations, the description carries the full burden: it only hints at read-only via 'See' and does not disclose whether the ranking is global, whether it returns player identities, how fresh the data is, or any access constraints. Nothing about result shape, ordering, or paging behavior is described beyond what the schema already states.

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

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

A single front-loaded sentence with no filler. It is efficient, though it leaves no room for any of the context an agent would need.

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

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

There is no output schema and no annotations, so the description should explain what a leaderboard entry contains (rank, player, net worth?) and what notification_message does. Neither is covered, leaving an agent unable to predict the response.

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

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

Schema description coverage is 100% and each of page, page_size, and notification_message is documented in-schema, so baseline 3 applies. The description adds no meaning about paging or the unusual notification_message parameter, which appears nowhere in the prose.

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

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

States a specific verb and resource: an in-game 'Forbes list' of the richest players, which clearly identifies a ranked leaderboard read. No sibling tool in the list covers leaderboards, so differentiation is implicit rather than stated.

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

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

The description never says when to reach for this tool, when not to, or what alternative to use instead. Usage is only inferable from the word 'See' and the Forbes framing.

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

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

With no annotations present, the description carries the full behavioral burden, and it does add one genuinely useful fact: the list is static and synced from the game client, so data may lag. It stops short of covering staleness/sync cadence, whether pagination or ordering applies, or read-only safety semantics.

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 clauses with the core identity front-loaded and no filler. The trailing fragment about optional filters is terse and slightly clipped, but overall it is efficient rather than under-specified.

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-required-parameter read tool with full schema coverage and no output schema, the description covers what the tool is and that filtering is optional. Missing only sibling disambiguation and any hint of result size/ordering.

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

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

Schema coverage is 100%, so all three parameters are already documented, and the description merely echoes the two filters (category, max price) and omits notification_message entirely. Baseline 3 applies since the schema does the heavy lifting.

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

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

The description states a specific verb and resource (furniture/décor catalog) plus a distinguishing property: prices in ₦ and a static list synced from the game client. It does not, however, differentiate itself from the sibling get_home_catalog, leaving the agent to infer why two catalog tools exist.

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 only usage signal is that filtering is optional, which tells the agent nothing about when to reach for this tool versus get_home_catalog, apply_home_design, or preview_home_design. No exclusions, prerequisites, or alternatives are named.

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

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

No annotations are provided, so the description carries the full burden. The 'GET /api/homes' notation implicitly conveys a read-only, non-destructive listing, which is useful. However, it says nothing about pagination, result size, permissions/authentication, or the odd notification_message side-channel, leaving real behavioural gaps.

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

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

Two short sentences, front-loaded with the core purpose and followed by the disambiguation. The 'Not the furniture shop' clause earns its place given the shared vocabulary, though the raw endpoint path is of marginal value to 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 one-parameter read tool with no output schema, the description covers the essentials of what it does. But it omits any differentiation from list_neighbour_homes and leaves the unusual notification_message parameter unexplained, so it is adequate rather than complete.

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

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

Schema description coverage is 100% and there is only one optional parameter, so the schema already documents notification_message fully; baseline 3 applies. The description adds nothing about how that parameter relates to a listing call, which is arguably the most confusing part of the tool.

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

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

States a specific verb and resource ('List neighbour homes you can visit') and even names the underlying endpoint, so the operation is unambiguous. It explicitly rules out the furniture-shop confusion, but it does not distinguish itself from the near-duplicate sibling list_neighbour_homes (or list_map_homes), which is the other plausible source of misselection.

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

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

Gives a clear selection rule against one alternative: 'Not the furniture shop — use get_furniture_catalog for Buy mode items.' That is a genuine when/when-not statement. It stops short of covering the remaining ambiguous siblings, so it is strong but not exhaustive.

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

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

With no annotations, the description carries the full behavioral burden. It implies a read-only snapshot, but never states permissions/auth needs, what happens if the player has no home, or that the call is side-effect free. The inexplicable notification_message parameter (a write-style concern) is left unaddressed, which makes the tool's behavior profile ambiguous.

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

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

A single front-loaded sentence that lists the returned data with no filler. It is a sentence fragment lacking a verb, but nothing is wasted.

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

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

With no output schema, listing the returned fields is genuinely useful and largely substitutes for one. However, for a read of complex nested state (grid positions, storage) it does not hint at structure, size, or failure modes, leaving minor gaps for an agent.

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

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

Schema description coverage is 100% and the single parameter's purpose (a fallback user-facing message) is documented in the schema itself. The description adds nothing about it, but at full coverage the schema does the work, so baseline 3 applies.

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

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

The description names the specific resource — the player's own current home — and enumerates the returned data (furniture grid positions, storage, decor score, cash). It reads as a fragment without an explicit verb, and it doesn't explicitly contrast itself with siblings like preview_home_design or get_decorator_job_layout, but the scope is clear enough that an agent can distinguish it.

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

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

There is no statement of when to call this versus the closely related siblings (preview_home_design, propose_home_design, get_home_catalog, get_decorator_job_layout). The phrase 'Your current home' weakly implies reading the caller's own home state, but no explicit conditions, exclusions, or prerequisites 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 exist, so the description carries the full burden. 'Load' implies a non-mutating read and the field list describes what is returned, which is useful, but it never states that it is read-only, that it operates on the caller's own account only, or what happens if the session is unauthenticated.

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

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

One sentence, front-loaded with the verb and resource, with the returned fields listed immediately after. No filler or hedging; every clause carries 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?

With no output schema, the description usefully enumerates the returned fields, which is the main gap it needed to fill. Missing only authentication/error expectations, which are minor for a self-read tool.

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

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

Schema description coverage is 100% for the single optional notification_message parameter, so the baseline is 3. The description does not mention this parameter at all, adding no semantics beyond the schema.

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

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

States a specific verb ('Load') and resource ('your sim profile') and enumerates the payload (avatar, bio, account details), so the agent knows exactly what comes back. It does not explicitly contrast with nearby siblings like session_status or get_wallet_and_job, but the self-profile framing is distinct enough to be recognizable.

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

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

Usage is only implied: the possessive 'your' scopes it to the authenticated caller's own profile, which implicitly rules out other-player lookups (search_players, get_chat_with_player). There is no explicit when-to-use, when-not, or named alternative.

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

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

No annotations are provided, so the description carries the full burden and doesn't even state that the call is read-only. It also doesn't explain the notification_message fallback behavior (a message shown if the follow-up reply fails), which is a non-obvious side effect a caller should know about. The description gives no permissions, limits, or failure-mode 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?

It is one compact sentence with the most useful item, wallet balance, placed first. The only waste is the closing phrase 'how your sim is doing', which is vague and slightly underspecified rather than verbose.

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

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

There is no output schema and no annotations, so the description needs to do more than this. It states what is returned at a high level, but never clarifies what 'how your sim is doing' means (health, needs, mood, stats) or what the response looks like. For a multi-part read tool, this is adequate but 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?

Schema description coverage is 100%, so the single notification_message parameter is already fully documented in the schema. The description adds nothing about it, and no syntax or format nuance is needed here. Baseline 3 applies because the schema does all the work.

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 specific resources: wallet balance (with currency), current job, and sim status. The verb 'See' is weak, and 'how your sim is doing' is vague, but an agent can reasonably tell this is a composite read of player status. It doesn't differentiate from siblings like get_wallet_pending, get_my_profile, or list_job_careers, which overlap on parts of this 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?

There is no guidance on when to use this tool instead of get_wallet_pending, get_my_profile, or list_job_careers. No exclusions, prerequisites, or context are given, so the agent must infer routing from tool names alone.

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

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

With no annotations, the description carries the full behavioral burden and provides little beyond the purpose. It does not confirm read-only behavior, explain what 'pending' statuses mean, describe permissions or side effects, or indicate what the response contains.

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 filler or redundant phrasing. It is appropriately sized for a simple read tool.

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

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

The tool is simple and its only parameter is fully described in the schema, so the description is minimally sufficient to identify the action. However, with no annotations and no output schema, it should say more about what 'pending' results include and how this differs from related wallet 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?

The sole parameter, notification_message, is fully documented in the schema, so the schema already carries the parameter semantics. The description adds no extra meaning about this parameter or its role in a 'get' operation, which is acceptable given 100% schema coverage.

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

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

The description uses a clear verb, 'Check,' and a specific resource, 'pending wallet top-ups or purchases,' scoped to the account. It distinguishes the tool's focus from wallet-balance or top-up action siblings only implicitly, without naming 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 gives no explicit guidance on when to use this tool versus siblings such as get_wallet_and_job, free_wallet_topup, or purchase_discounted_credits. The 'pending' framing implies a use case, but there are no exclusions, prerequisites, 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 disclosure burden. 'List' implies a read, but it never confirms read-only behavior, ordering, whether the list is paginated or bounded, or what a contact entry looks like; it also says nothing about the odd notification_message parameter's purpose for this action.

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

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

One short, front-loaded sentence with zero filler. It is efficient, though its brevity edges toward under-specification rather than optimizing information density.

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 simple — zero required params, full schema coverage, no output schema — so not much is needed. Still, for a listing tool with no annotations, the description omits any sense of what the returned contacts contain or how many, which an agent planning a follow-up would want.

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

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

Schema description coverage is 100% and the single optional notification_message is fully documented in the schema. The description adds no meaning beyond it, so the baseline 3 applies rather than a higher score.

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

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

States a specific verb and resource: listing players saved in the in-game Phone contacts. That is distinguishable from siblings like search_players or list_dm_threads in concept, but the description never explicitly contrasts them, so the agent must infer the boundary.

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

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

No guidance on when to use this versus search_players (search by name) or list_dm_threads (conversations). There are no prerequisites, no exclusions, and no indication of what the contacts list contains relative to other player-listing 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 at all, the description carries the full behavioral burden and leaves the important traits unstated. It never says how many conversations come back, how "recent" is bounded, what ordering applies, or whether auth/session is required. For a listing tool with zero annotation coverage this is a meaningful gap, though the read-only nature is strongly implied by "List".

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

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

A single front-loaded sentence with no filler or redundancy. Every clause earns its place by naming the resource, the scope, and the surface.

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 is minimally adequate but does not tell the agent what a returned "conversation" contains (participants, last message, unread state) or how many are returned. Without an output schema, that return-shape ambiguity is left entirely unaddressed.

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

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

Schema coverage is 100% and the single parameter (notification_message) is fully self-documented in the schema, so the baseline of 3 applies. The description adds nothing about that parameter, but it also does not need to.

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 pairs a specific verb ("List") with a well-defined resource ("private message conversations") and scopes it to the in-game Phone app, which cleanly separates it from send_dm and get_chat_with_player. It stops short of naming a sibling explicitly, so an agent must infer the inbox-vs-conversation distinction.

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

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

Usage is only implied: the word "recent" suggests an inbox/overview call, and the Phone app framing hints at the in-game messaging surface. There is no statement of when to prefer this over get_chat_with_player or list_contacts, and no prerequisites 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 exist, so the description carries the full burden. 'See available careers' implies a safe read, and the note that job switching occurs elsewhere usefully scopes behavior, but nothing is said about return contents, permissions, or whether the list is static or player-dependent.

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, zero filler, with the resource definition front-loaded and the usage caveat second. Every clause carries information.

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

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

For a simple listing tool this is close to adequate, but with no annotations and no output schema the description should say more about what a career entry contains (pay, requirements, application flow) so an agent knows what it can do with the result.

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

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

The single parameter (notification_message) is fully documented in the schema at 100% coverage, so baseline 3 applies. The description adds nothing about it, and it's a generic side-channel parameter unrelated to the core listing purpose, so no extra credit is warranted.

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

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

Specific verb ('See') plus resource ('available careers in the Jobs app') with concrete examples (Tech, Banking, Music) that tell an agent exactly what domain this covers. It doesn't explicitly contrast with siblings like get_wallet_and_job or get_decorator_job_layout, so it stops short of full sibling differentiation.

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

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

The second sentence draws a clear boundary: switching jobs happens in-game on the phone, not through this tool, which prevents a common misuse. It doesn't name the alternative tool or state prerequisites, but the when-not guidance is explicit.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Browse' implies a read operation and 'every home plot' suggests comprehensive coverage, but the description omits access requirements, pagination or completeness guarantees, and expected response 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 definition is a single front-loaded sentence with no wasted clauses. The parenthetical area examples add useful scope without becoming verbose.

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 list-style tool with one optional, fully described parameter, the description conveys the main content the agent will see. However, with no annotations and no output schema, it leaves gaps around return structure and behavioral expectations.

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 single optional notification_message parameter is fully documented in the schema (100% coverage), so the description does not need to repeat its meaning. It therefore meets the baseline for a schema-rich parameter.

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

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

The description gives a specific verb and resource ('Browse the city map') and enumerates the data shown: home plots, residents, online status, and at-home status. It is clear what the tool does, but it does not explicitly differentiate itself from close siblings such as list_neighbour_homes or map_online_stats.

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 a browsing use case but gives no explicit when-to-use guidance, exclusions, or alternatives. With overlapping sibling tools like list_neighbour_homes and map_online_stats, an agent has to infer which tool to choose.

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 burden. It does disclose the underlying endpoint (GET /api/homes), implying a read-only operation, and flags the alias identity, which prevents redundant exploration. It omits return shape, pagination, and scope (whose neighbours, how many) — meaningful gaps for a no-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?

Two short sentences with zero waste; the resource is front-loaded and the disambiguating alias note follows immediately. Nothing to trim.

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

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

For a simple read tool with full schema coverage and no output schema, the essentials are present, and the alias note is genuinely useful. But with two closely related siblings (get_home_catalog, list_map_homes) and no annotations, it should say more about what data comes back and how it differs from list_map_homes.

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

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

Schema description coverage is 100%, so the single optional notification_message parameter is already fully documented. The description adds no parameter-level semantics beyond the schema. Baseline 3 applies when the schema does the heavy lifting.

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

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

States a specific resource (neighbour homes you can visit) and clarifies its relationship to a sibling by declaring it an alias of get_home_catalog. That alias note lets an agent tell it apart from get_home_catalog without opening either schema. It doesn't resolve the distinction from list_map_homes, but the core purpose is clear.

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

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

'Alias of get_home_catalog' gives an implicit use signal — either tool works and behavior is identical. However, it never states when to prefer this over get_home_catalog or how it differs from the sibling list_map_homes, leaving the agent to infer the selection logic.

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

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

With no annotations, the description carries the full behavioral burden and does well: it discloses that the password must never be asked for in chat text, is used only for the game login, and is not echoed. It does not describe failure behavior or session persistence, so it falls short of a 5 but is still strong for a security-sensitive action.

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

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

The description is front-loaded with the core action, followed by the prerequisite check, credential collection method, and security constraint. Every sentence earns its place and there is no filler.

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

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

For a login tool with no output schema and no annotations, the description covers the essential invocation path, prerequisite, credential handling, and security constraint. It could be more complete by noting what a successful login returns or how failures should be handled, but it is sufficient for an agent 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 100%, so the baseline is 3. The description names the credential parameters and adds security context, but much of that repeats the schema's own descriptions (secret password, username format). The emit_display collection method is useful procedural context, but it does not add substantial meaning about the parameters themselves.

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 begins with a specific verb and resource: "Sign in to Lagos Life." It clearly identifies the tool as an authentication/session-creation action, distinguishing it from session_status by explicitly saying to call session_status first and use login only if not already signed in.

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

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

It gives explicit when-to-use guidance: call session_status first, then use login only if the user is not already signed in. It also specifies how to collect credentials via emit_display interaction_mode input, which is precise operational guidance rather than 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?

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only summary and names the returned aggregates, but it omits permissions, freshness, rate limits, and whether the requester is included.

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

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

The description is a single concise sentence with the main content front-loaded. 'Friendly' is minor framing, but nothing materially wasteful is present.

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 aggregate-read tool with no output schema, the description sufficiently names the return categories and the schema covers the only parameter. It could be more complete by explaining access requirements or freshness, but the core invocation information is present.

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

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

Schema description coverage is 100%, and the single optional notification_message parameter is fully documented in the schema. The description adds no parameter meaning beyond the schema, so the baseline score applies.

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

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

The description states a specific resource and metrics: totals online, at home, and counts by neighborhood for the city map. It is clear what the tool summarizes, though it does not explicitly distinguish itself from siblings such as list_map_homes or list_neighbour_homes.

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 when-to-use guidance or comparison to alternatives. An agent can infer it is for aggregate map statistics, but the description does not say when to choose this over list_map_homes, list_neighbour_homes, or search_players.

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

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

With no annotations, the description carries the full burden and does well: it discloses that there is no automatic layout, that only agent-supplied placements appear, and that the result feeds apply_home_design rather than mutating state. It does not explicitly say the preview is non-persistent or how the budget cap affects validation, leaving a small gap.

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

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

Three compact clauses, front-loaded with the core before/after distinction, then constraints, then outputs. No redundant restatement of the 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?

Covers the prerequisites, the key constraint (no auto layout), and the return values that route into apply_home_design. Missing only whether the preview has side effects and how home_design_max_budget_ngn interacts with validation, which matters for a 5-parameter tool with no annotations.

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

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

Schema coverage is 100%, so baseline is 3. The description reinforces the placements semantics (type, x, y, rot per piece, not auto-generated), but adds no detail about style, notification_message, budget cap, or the legacy JSON string parameter beyond what the schema already says.

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

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

States a specific verb+resource (before/after 3D preview of a home design) and immediately defines what each side means, so an agent can tell it apart from apply_home_design and propose_home_design without reading their schemas.

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

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

Gives explicit prerequisites ("Call get_home_layout + get_furniture_catalog first") and names the downstream tool (apply_home_design). It stops short of stating when to choose propose_home_design instead, which is the one remaining ambiguity among siblings.

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

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

With no annotations, the description carries the full behavioral burden. It discloses only that placements are not automatic; it does not say whether the tool is read-only or mutating, whether it creates a proposal, what permissions are needed, or what happens to budget/style inputs.

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

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

The description is short and front-loaded, with no filler. Its terseness is appropriate structurally, though it leaves important gaps that other dimensions penalize.

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 five-parameter tool with a nested placements array, no annotations, and no output schema. The description does not explain the return behavior, side effects, budget semantics, or most parameters, so it is not complete enough for reliable 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 only 20%, and the description explains only home_design_placements. It says nothing about home_design_style, home_design_max_budget_ngn, home_design_placements_json, or the distinction between the array and JSON placement parameters.

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 this as a legacy alias of preview_home_design and states that placements must be supplied manually. However, it does not independently state what the tool does in verb+resource terms, so an agent must already understand preview_home_design to know the actual effect.

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?

Calling it a 'legacy tool name' hints that preview_home_design may be preferred, but the description never explicitly says when to use this tool versus preview_home_design or apply_home_design. No prerequisites or exclusion conditions are given.

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

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

With no annotations, the description carries the full behavioral burden. It usefully explains the interactive flow—opening an HTML shop, selecting a pack, and entering details on Nova checkout—but does not cover payment safety, prerequisites, irreversibility, or what happens after checkout, leaving meaningful gaps for a purchase-adjacent 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 three tight sentences that are front-loaded: purpose and discount first, then the usage condition, then the user flow. Every sentence carries useful information without redundancy.

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

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

For a simple one-parameter tool with no output schema and no annotations, the description explains enough of the shop and checkout flow for an agent to select and invoke it correctly. Minor gaps remain around post-checkout behavior and how the optional notification_message fits into the flow.

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

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

Schema description coverage is 100%, so the sole parameter is already documented in the schema. The description does not mention notification_message or add any semantics beyond the schema, which is the baseline case for full schema coverage.

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

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

The description states a specific verb and resource: opening the discounted Lagos Life wallet shop for paid wallet credits. It implicitly distinguishes itself from the free top-up sibling by emphasizing 'paid' and 'bank transfer', but it does not explicitly name or contrast with the alternative tool.

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

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

It gives a clear usage condition: 'Use when the player wants paid in-game wallet credits via bank transfer.' It does not state when not to use the tool or explicitly name alternatives such as free_wallet_topup, so it falls short of the highest level.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that session cookies are set on success and that credentials should be stored, but it does not describe failure modes, permissions, rate limits, or whether account creation is reversible.

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

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

The description is front-loaded with the core purpose, then adds usage, parameter guidance, and post-success behavior in a compact sequence. Every sentence contributes useful information.

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

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

For a no-annotation signup tool with full schema descriptions and no output schema, the definition covers purpose, usage, key parameter constraints, and the main side effect. It could be more complete about errors or account persistence, but the essentials are present.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaningful username constraints beyond the schema: the 3–20 character length and allowed character set. It also explains that the password should be collected via emit_display input.

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

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

The description gives a specific verb and resource: "Create a new Lagos Life account (sign-up)." It also distinguishes the intended operator broadcast context from ordinary login or account-management siblings.

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

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

It explicitly says to use this for operator broadcast accounts and states the username constraint that applies in that context. It does not state when not to use it or name an alternative sibling, so it falls short of full 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?

With no annotations, the description carries the full burden and does not disclose the consequences of filing a report — whether the target is notified, whether reports are permanent/irreversible, or whether permission or evidence is required. Only the confirm-with-user caution adds behavioral value; the side effects of this mutation remain opaque.

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

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

A single compact sentence with the primary action front-loaded and the safety caution properly parenthesized. Efficient, though the brevity contributes to the behavioral and parameter gaps above.

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 three-parameter mutation tool with no annotations, no output schema, and only one-third schema coverage needs substantially more description than one sentence. An agent still cannot tell what a successful report returns, whether the report is visible to the accused, or how to phrase the required note.

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 only 33% — 'notification_message' is documented in the schema, but 'report_note' and 'report_target_user_id' are bare strings with no explanation anywhere. The description does not compensate: it never explains what a report note should contain or the expected format of the target user ID.

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

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

States a specific verb ('report') and resource ('another player to in-game police'), which is unambiguous on its own. No sibling tool performs reporting, so differentiation is implicit rather than stated, keeping it just short of a 5.

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

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

The parenthetical 'confirm details with the user first' supplies a real precondition for invoking the tool. However, it offers no guidance on when reporting is appropriate versus, say, using send_dm or get_chat_with_player to resolve an issue, nor any 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 full behavioral burden, yet it discloses nothing about side effects, whether matches are exact or partial, rate limits, or what is returned. The existence of a notification_message parameter for a purported lookup tool hints at side effects or a follow-up interaction, which the description never addresses.

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

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

A single short sentence with the resource front-loaded and no filler. The Phone analogy adds orientation cheaply, though it consumes the only sentence without conveying behavior.

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 2-parameter, annotation-free tool with no output schema, the definition is only minimally complete: it never explains the notification_message parameter's role in this tool's flow or what a search returns. The schema covers the mechanics, but behavior around side effects is missing.

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

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

Schema coverage is 100%, so both parameters are documented in the schema, including the '@' optionality and notification_message failure semantics. The description only echoes 'by username,' adding no meaning beyond the schema, so the baseline 3 is appropriate.

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

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

States a specific verb and resource (find a player) and uses the in-game Phone analogy to anchor the search concept, and 'another player' implicitly distinguishes it from get_my_profile. However, it doesn't explicitly differentiate from near-neighbors like list_contacts or get_chat_with_player, which also deal with other players.

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

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

Usage is implied by 'Find another player by username,' but there is no explicit when-to-use, when-not-to-use, or named alternative (e.g., list_contacts when the player is already a contact). The agent must infer routing from sibling names alone.

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

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

With no annotations, the description carries the full burden. It discloses that this sends exactly one private message through the in-game Phone and requires user confirmation, which adds useful context. It does not cover permissions, recipient validity requirements, rate limits, or what happens on failure.

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 well-formed sentence with the key action and confirmation prerequisite front-loaded. There is no wasted wording.

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

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

This is a simple three-parameter action with fully described schema fields and no output schema. The description covers the action and confirmation requirement, but with no annotations and no return-value details, it leaves behavioral gaps for a mutating messaging tool.

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

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

Schema description coverage is 100%, so all three parameters are already documented in the input schema. The description adds only high-level context around confirming the message text, which maps loosely to dm_body, but adds no syntax or constraints beyond the schema.

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

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

The description states a specific verb and resource: send one private text to another player through the in-game Phone. This clearly distinguishes it from read-oriented siblings such as list_dm_threads and get_chat_with_player, though it does not explicitly name those alternatives.

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

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

The parenthetical instruction to confirm message text with the user first is useful operational guidance. However, it does not say when to use this tool versus alternatives like search_players for finding a recipient or list_dm_threads for reading conversations.

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

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

With no annotations, the description carries the full burden. It usefully discloses that funds come from the existing game balance, that this is not real money, and that confirmation is required, but it does not state irreversibility, immediate balance deduction, failure behavior, or any rate limits. This is adequate but leaves meaningful behavioral gaps for a money-transfer mutation.

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 compact and front-loaded, stating the primary action first, then the exclusion and alternative, then the confirmation requirement. Each clause earns its place and there is no redundant restatement of the schema.

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

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

For a mutation tool with no annotations and no output schema, the description covers purpose, exclusion, alternative tool, and a confirmation safeguard. However, it omits consequences such as irreversible transfer or what happens on insufficient balance, leaving the agent without important operational context.

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

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

Schema description coverage is 100%, so all four parameters are already documented in the schema. The description highlights the two required parameters via the confirmation instruction but adds no syntax or format detail beyond what the schema provides, so baseline 3 applies.

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

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

States a specific verb and resource: sending in-game naira from the player's existing game balance to another player. It also names the alternative tool purchase_discounted_credits for a different money-related action, so the agent can distinguish it from siblings without opening the schema.

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

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

Explicitly says this is NOT a real-money top-up and directs the agent to use purchase_discounted_credits for Nova discounted wallet shop, covering when-not-to-use and naming the alternative. It also adds a clear prerequisite: confirm recipient id and amount with the user first.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the two pieces of state returned, and the read-only nature is implied by "check," but it does not say what happens when the caller is not signed in (error vs. a signed-out result), nor anything about cost 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?

One sentence, front-loaded with the check, with zero filler. Nothing could be removed without losing 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 zero-required-parameter read tool with no output schema and full schema coverage, the description covers what is returned and why an agent would call it. The only gap is the signed-out outcome, which matters for deciding whether to call login next.

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 single parameter (notification_message) is fully documented in the schema at 100% coverage, so the schema does the work. The description adds no additional meaning about when that fallback message is surfaced, which is the baseline-3 case.

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

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

States a specific verb ("check") and resource (session/sign-in state plus current character), which is enough to tell it apart from login/register (which establish a session) and get_my_profile (which returns profile detail). It stops short of explicitly naming those siblings, so it is clear but not maximally differentiated.

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

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

Usage is only implied: the phrase "whether you are signed in" suggests a pre-flight check before authenticated actions, but there is no explicit when-to-use, when-not, or named alternative (e.g., use login if this reports signed out).

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