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

With no annotations provided, the description carries the burden of behavioral disclosure. It adds value by stating that alarms are 'decoded with sender device and fault type,' but does not cover side effects, rate limits, or what happens when no alarms exist. This is adequate but not comprehensive.

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, focused sentence that front-loads the core purpose. It is concise and avoids redundancy, though it could be slightly more structured with a separate sentence for usage 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?

Given the tool has two well-described parameters and no output schema, the description provides sufficient context about what the tool returns (decoded alarms and faults). It is complete enough for an agent to understand its function, though a note on pagination or default behavior would improve completeness.

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 does not add meaningful information beyond what the schema already provides for the parameters (controllerId and includeCleared). The examples in the description are about the output, not the 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 clearly states it retrieves active alarms and faults for a controller, with specific examples like valve short circuits and flow comm failures. It is distinct from sibling tools such as baseline_get_history or baseline_get_status, which serve different purposes.

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 for checking alarms but does not provide explicit guidance on when to use this tool versus alternatives, nor does it mention exclusions or prerequisites. The context of 'for a controller' is clear but lacks comparative direction.

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 bears full responsibility. It discloses the output format (plain text) and the nature of content (vendor proactive notifications), but omits behavioral details like read-only nature, permissions, or what happens when no announcements 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 one sentence of 12 words, front-loading the key concepts 'vendor proactive notifications' and 'plain text'. Every word adds value; no fluff.

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 and no output schema, the description provides a basic idea but lacks detail on scope (current vs. all announcements), retrieval behavior (e.g., empty response), or response structure. For a zero-parameter tool, it is adequate but not fully comprehensive.

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 schema coverage is 100%. The description adds no parameter-specific information, which is acceptable since there are none. Baseline score for no parameters is 4.

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

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

The description states 'Vendor proactive notifications (e.g. scheduled server-maintenance banners), as plain text', which clearly identifies the resource (system announcements) and format (plain text). The verb 'Get' is in the title, but the description doesn't repeat it; however, the context makes retrieval obvious. It distinguishes from siblings like baseline_get_alarms by specifying 'vendor proactive notifications'.

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 vs alternatives (e.g., baseline_get_alarms). The description only defines what it retrieves, without explaining scenarios 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 full burden. It discloses the return format (max/min/average/median plus per-bucket points) and acceptable date formats. However, it lacks information on potential behavioral traits like data limits, pagination, or authentication 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 concise with 4 sentences, each adding distinct information: purpose, kinds, data source, date format, and return structure. Front-loaded with the core purpose.

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 tool has 6 parameters and no output schema, the description adequately covers purpose, parameter sources, date formats, and return structure. It could mention ordering or record limits, but overall it provides sufficient context for an agent to use the tool effectively.

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 adds value by explaining the source of deviceSn (from baseline_list_devices), date format (ISO-8601 or YYYY-MM-DD), and default granularity (day). This clarifies meaning beyond the schema 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 clearly states it provides historical time-series for a single device, lists the metric kinds, and distinguishes itself from siblings like baseline_get_live (real-time) and baseline_get_report (reports). It uses a specific verb 'get' and resource 'history series', making purpose unambiguous.

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

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

The description tells when to use this tool by specifying it is the source for historical pressure and per-zone/flow/moisture/temperature trends. It does not explicitly state when not to use it, but the context of siblings implies alternatives. It also clarifies how to obtain deviceSn from another tool.

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

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

No annotations are provided, so the description carries the full burden. It honestly describes the return data: decoded status, key/value readings, and primary value per sensor type. However, it does not disclose read-only nature, rate limits, or authentication requirements, leaving 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?

The description is concise with three sentences, each adding unique value. It front-loads the main purpose, includes parameter context, and ends with a pairing suggestion. No unnecessary words.

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 output schema, the description adequately explains return values with sensor-type mappings and suggests pairing with history. It lacks details on error handling, rate limits, or auth, but for a simple read tool this is mostly 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?

Parameter schema coverage is 100% with adequate descriptions. The description adds minimal extra meaning: it clarifies deviceSn source (serialNumber or decoderSN) and optionality of controllerId given account conditions. No significant value beyond 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 clearly states the tool returns the current live reading for one enumerated device, identified by its reporting serial. It specifies the verb 'get', the resource 'live reading', and distinguishes from sibling tool baseline_get_history by explicitly mentioning it for trends.

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 clear context for when to use this tool: for live readings of a single device. It suggests pairing with baseline_get_history for trends, offering guidance on alternatives. However, it does not explicitly state when not to use it or contrast with other siblings like baseline_get_status.

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 behavioral traits. It only states the data source ('Sourced from the controller config'), but does not mention read-only nature, permissions, rate limits, or whether the data is real-time. This leaves significant gaps for an agent to understand 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 a single sentence that front-loads the main purpose and adds a source note. It is concise but could be improved with bullet points for the listed fields or more structured formatting; still, it is effective and wastes no words.

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 tool with one optional parameter and no output schema, the description adequately lists all returned fields and their source. It is sufficient for an agent to understand what the tool returns, though without an output schema, it relies entirely on the description for return value understanding.

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%, covering the controllerId parameter's optionality conditions. The description adds no extra semantic meaning beyond what the schema already provides, so a baseline score of 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 clearly states the verb (List), the resource (watering programs), and enumerates the specific fields returned, including last start/finish, duration, water used, next scheduled start/finish, and assigned zones. It distinguishes itself from sibling tools like baseline_get_history or baseline_list_zones by specifying exactly what program-related information is provided.

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 by listing the data returned and mentioning the controller source, but lacks explicit guidance on when to use this tool versus alternatives like baseline_get_history or baseline_get_live. No prerequisites or conditions are stated beyond the parameter dependency on a controller.

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 provided, so description must cover behavioral traits. It specifies that output is 'aligned timestamp/value points' but omits details on rate limits, authentication, data volume, or side effects. Lacks important operational context for a mutation-free 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?

Three sentences, no filler, front-loaded with primary action. Efficiently conveys purpose, types, date format, and scoping 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?

Covers main aspects (purpose, types, date format, scoping) but lacks explanation of 'resolution' parameter (default daily) and output structure beyond 'aligned timestamp/value points'. With no output schema, more detail on return format would improve usability.

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 description adds little beyond the schema. It repeats type enum, date format, and id usage, but does not provide new semantics or constraints. Baseline of 3 is appropriate as the description does not detract but does not enhance understanding.

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?

Clearly states 'Fetch a reporting time-series for a controller' with specific resource (controller) and verb (fetch). Lists all report types, date format, and scope option, distinguishing it from sibling tools which are other data retrieval or list operations.

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?

Provides clear context on when to use the 'id' parameter (scope to single zone/device vs. omit for controller-wide). Does not explicitly mention alternatives or when not to use the tool, but the distinct purpose and sibling list imply appropriateness for time-series data.

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

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

No annotations are provided, so the description must fully disclose behavioral traits. It describes the output content (status codes and sensor readings) but omits critical details such as whether the call is read-only, any performance or rate-limiting considerations, or whether it returns raw or processed data.

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 focused sentence that efficiently conveys the tool's purpose and key outputs. It is compact and free of extraneous information, though it could be slightly more structured by separating the list of output elements.

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?

Without an output schema, the description fairly covers what to expect: overall status, per-zone and per-device status codes, and decoded sensor readings. This provides sufficient context for an agent to understand the return value shape and decide to invoke 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 input schema already provides a thorough description for the single parameter controllerId, including optionality rules. The description adds no additional meaning beyond what the schema states. With 100% schema coverage, a score of 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 'Live snapshot' as a strong verb+resource combination and lists specific outputs (overall status, per-zone and per-device status codes, decoded sensor readings) that clearly distinguish it from sibling tools like baseline_get_alarms or baseline_get_history.

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 for retrieving a live controller snapshot but provides no explicit guidance on when to use it versus alternatives like baseline_get_live or baseline_get_programs. The schema hints at conditional requirement for controllerId, but that is parameter-level, not usage 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 must carry the full burden. It only says 'list', which implies a read operation, but does not disclose any behavioral traits such as pagination, rate limits, authentication, or what the response contains. For a tool with zero annotations, this is insufficient.

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

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

Two sentences with no wasted words. Front-loaded with the primary action, followed by a usage hint. Highly concise and well-structured.

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 tool's simplicity (no params, no output schema), the description covers the core purpose and provides actionable guidance on using the result. Could mention the response format (array of companies), but overall 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?

No parameters in schema. The description adds value by explaining the purpose of the tool and how the output (companyId) can be used downstream. With 0 parameters, baseline is 4, and the description meets expectations.

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?

Description clearly states it lists organizations accessible to the account. Verb 'list' and resource 'organizations (companies)' are specific. Distinguishes from sibling tools like baseline_list_controllers by mentioning companyId usage.

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

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

Explicitly states that the output companyId can be used to scope baseline_list_controllers or set via BASELINE_COMPANY_ID. Provides clear context for using the result, but does not explicitly mention when not to use this tool.

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

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

With no annotations, the description implies a read operation across accessible organizations, but does not disclose pagination, performance, or rate limits, which is acceptable for a list 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 efficient sentences front-load the core purpose and parameter usage, with no wasted words.

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 output schema, the description adequately lists return fields and scope, but lacks mention of error handling or authentication requirements.

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 100% coverage with a description for companyId, and the tool description adds value by linking to baseline_list_companies as a source for the parameter, enhancing context.

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 it lists sites and controllers with detailed fields (model, firmware, etc.), distinguishing it from siblings like baseline_list_companies or baseline_list_devices.

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 specifies when to use (across all orgs) and how to limit (pass companyId), providing clear context though no explicit alternatives 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?

With no annotations, the description should disclose behavioral traits. It implies a read operation by stating 'enumerate', but does not explicitly confirm no side effects or permission requirements, leaving some ambiguity for an AI agent.

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, information-dense sentence with no wasted words. It front-loads the core action and provides necessary context efficiently.

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 tool with one parameter and no output schema, the description covers the essential aspects: what it lists, how it groups, what identifiers to capture, and parameter optionality. It is sufficiently complete for invocation.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining the optionality of controllerId (when one controller or env var set) and the grouped output, which enhances understanding 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 clearly states the tool enumerates every device on a controller grouped by type, distinguishing it from siblings like baseline_list_controllers and baseline_list_zones. It also specifies the inclusion of reportingSn for downstream use.

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 clear context by mentioning the output can be used to pass deviceSn to baseline_get_history, implying its utility. However, it lacks explicit when-to-use or when-not-to-use guidance relative to sibling tools.

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

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

No annotations are provided, and the description does not disclose behavioral traits such as whether the operation is read-only, destructive, or subject to rate limits/permissions. For a list operation, the agent needs to know it's safe; the description fails to convey this.

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 sentence with no extraneous information. It is front-loaded with 'Zone configuration for a controller' which sets context. However, it could be more structured (e.g., separating the action from the content description).

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

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

The description lists the specific output fields, which is helpful. However, it does not specify return format, ordering, or pagination. Additionally, missing behavioral transparency reduces completeness for effective 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 coverage is 100% and the parameter description already explains the optionality clearly. The tool description does not add any additional meaning or context about the parameter beyond what the schema provides, so it meets minimum expectations.

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 title 'List zones' clarifies the action, but the description focuses on the output fields ('number, name, decoder serial...') rather than explicitly stating the tool lists zones. It conveys the resource but lacks a clear verb, making it slightly vague.

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 context on when the controllerId parameter is optional vs required, which is helpful. However, there is no guidance on when to use this tool over siblings like baseline_get_programs or baseline_get_status, limiting its utility for tool selection.

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 convey behavioral traits. It indicates a read-only operation (validate and return), but does not mention error conditions, side effects (e.g., session expiry handling), or that no mutations occur. Adequate but not thorough.

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

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

A single sentence of 20 words, front-loading the key action 'validate the session and return'. Every word earns its place; no 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?

Given no output schema, the description lists all return fields (user, access level, company, controller ids). While it could detail exact field names or types, it covers the essential information for a whoami tool. Sibling tools are similar in nature, so context is consistent.

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 coverage is 100% (empty schema). The description adds value by specifying what is returned (user, access level, company, controller ids), 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 clearly states the tool validates the session and returns specific identity information (user, access level, company, controller ids). The title 'Who am I' reinforces this purpose, distinguishing it from siblings that retrieve alarms, announcements, etc.

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

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

The description implies usage for session validation and identity retrieval, but does not explicitly state when to use this tool versus alternatives or provide exclusions. Context suggests it's for authentication checks, but lacks explicit guidance.

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