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

There are no annotations, so the description carries the full burden of behavioral disclosure. It states that this is a write tool, which implies mutation, but it does not disclose any requirements around connections, authorization, idempotency, or side effects beyond creating an annotation. The word 'Create' already signals a write, so the description adds little behavioral nuance.

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 no redundancy, and the core action is stated first. The second sentence adds useful context by identifying this as the write tool, making every sentence earn its place.

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

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

The tool is simple on the surface, but with no annotations and no parameter descriptions, an agent lacks key information needed to call it correctly. It is not told what values are expected for text, tags, or session_name, or whether a prior connection is required. Even for a low-complexity tool, this is 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 0%, and the description mentions none of the three parameters (text, tags, session_name). It therefore does nothing to compensate for the schema's lack of explanatory detail. An agent is left to guess what 'text' should contain or what 'session_name' controls.

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

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

The description names a specific action ('Create') and resource ('Grafana annotation'), so an agent knows exactly what operation this performs. The phrase 'write tool for observability' contrasts with read-oriented siblings like obs_query_metrics and obs_get_trace, making its purpose distinct.

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 clearly implies this is the tool to use when writing/creating observability data, and the sibling list makes the alternative read tools obvious. It does not explicitly say 'use this instead of X when you need to annotate,' but the write-vs-read distinction is strong enough for an agent to route correctly.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states that it saves URLs and probes health endpoints, but it does not explain the side effects (e.g., whether it modifies persistent state), what happens on failed probes, whether authentication (like grafana_token) is required, or if the operation is safe/reversible. The 'probe' behavior is mentioned but not detailed, leaving significant gaps for a tool that likely establishes connections.

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

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

The description is a single, compact sentence that front-loads the core action ('Save backend URLs') followed by the health-check behavior. It is concise and avoids fluff, though it is arguably too terse to carry the necessary detail for a tool with six parameters and no annotations.

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 complexity (6 params, no annotations, no schema descriptions), the description is severely incomplete. It does not explain what each URL does, the purpose of session_name, how the token is used, what the output schema contains, or how the health probes are performed and reported. An agent would be unable to correctly fill parameters or interpret results without additional information.

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

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

The input schema has 6 parameters with 0% description coverage, so the description must compensate. It only mentions 'backend URLs' generically, not the specific parameters like loki_url, tempo_url, grafana_url, session_name, grafana_token, or prometheus_url. It does not explain the role of session_name or the token, nor the format of the URLs. The description adds almost no semantic value over the raw schema.

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

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

The description clearly states the action: 'Save backend URLs and probe /ready or Grafana /api/health.' It identifies the specific resource (backend URLs) and the two health-check endpoints, distinguishing it from siblings like obs_disconnect (disconnect) and obs_status (status check). The verb 'save' and 'probe' are specific and the scope is unambiguous.

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

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

The description provides no guidance on when to use this tool versus the alternatives. It does not mention prerequisites, typical use cases, or cases where another sibling (e.g., obs_status or obs_disconnect) would be more appropriate. The implied purpose of initial setup is present but not explicit, and there are no exclusions or alternatives 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?

With no annotations, the description carries the full burden of behavioral disclosure. It does not state whether dropping is destructive, idempotent, whether it fails on nonexistent sessions, or what happens to collected observability data. The description adds little beyond the tool name.

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

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

The description is a single sentence with no fluff and is easy to scan. However, it is overly terse for a lifecycle-management tool with no annotations and no parameter explanation, so it sacrifices necessary substance for brevity.

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

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

For a simple one-parameter tool, the description is too thin. It omits the relationship to obs_connect, whether the operation is reversible, and any side effects. The presence of an output schema helps but does not compensate for missing behavioral and usage 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 0%, and the description never mentions session_name or its default value. While the parameter name is self-explanatory, the description provides no additional meaning about how the parameter controls which session is dropped.

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

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

The description states a clear verb ('Drop') and a resource ('observability session'), matching the tool's disconnect intent. It is distinguishable from sibling tools like obs_connect and obs_status, though 'drop' is slightly ambiguous between delete and disconnect.

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

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

No guidance is provided on when to call this tool versus siblings, such as whether the session must be active or whether it should be called after obs_connect. Usage is only implied by the tool name and the generic phrasing.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It conveys the core computation but does not say what happens when the 5xx metric does not exist, what the response shape is, or whether it filters by a Prometheus label versus a service identifier. This is minimal transparency beyond the tool name.

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

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

The description is a single efficient sentence with no filler, and it places the core meaning first. However, it is so terse that it omits behavioral and parameter detail that would justify a longer 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?

For a tool with no annotations into a 2-parameter schema, the description says too little. It does not cover missing-metric behavior, session_name semantics, or when to use this versus obs_query_metrics. The existence of an output schema reduces the need to document return values, but the remaining gaps still leave an agent under-informed.

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

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

Schema description coverage is 0%, so the description must explain parameters. It contributes some meaning by suggesting 'service' is a label or selector for the metric, but 'session_name' is entirely unexplained, and no details are provided about accepted formats, defaults beyond the schema default, or how session_name affects the query.

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 ('HTTP 5xx rate') and a precise temporal scope ('over 5 minutes'), and adds a caveat ('if that metric exists'). It is distinguishable from generic siblings like obs_query_metrics, though it lacks an explicit verb such as 'get' or 'retrieve'.

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

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

No guidance is given about when to prefer this tool over obs_query_metrics or how to check whether the metric exists before calling. The conditional phrase implies the metric may be absent, but the resulting behavior is not described, so an agent is left guessing whether to call a sibling or handle an error.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'Fetch', which implies a read operation, but it does not describe what happens if the trace does not exist, whether a connection/session is required, or any side effects. The agent is left without important behavioral context.

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

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

The description is one short sentence with no filler or redundancy. It front-loads the core action and resource, making it immediately scannable for an agent.

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

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

Although the output schema is present, the description omits enough contextual detail for an agent to invoke the tool correctly in a broader workflow. It does not explain session_name, connection prerequisites, error behavior, or how this tool fits among its observability siblings. For a tool with no annotations, this leaves the agent undersupported.

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

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

Schema description coverage is 0%, so the description must compensate for the limited input schema. It clarifies that trace_id is the identifier used for lookup, but it does not explain the format or semantics of trace_id, nor does it explain the optional session_name parameter or its default behavior. This is insufficient given the lack of 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 states a specific verb ('Fetch'), a specific resource ('one Tempo trace'), and the key selector ('by id'). This clearly differentiates it from the sibling tool obs_search_traces, which is about searching rather than fetching a single known trace.

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 'by id' implies the tool should be used when a specific trace ID is already known, which provides implicit usage context. However, it does not explicitly state when not to use it, nor does it mention alternatives like obs_search_traces for finding traces without an ID.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only implies a read-only listing action but says nothing about output format, pagination, potential side effects, or any constraints. This is a significant gap for a tool with no annotation coverage.

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

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

The description is extremely short, but that is not conciseness—it is under-specification. It omits essential information that would be needed to use the tool correctly, making it inefficient rather than 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?

The tool has an output schema, but the description does not mention what the tool returns or any operational details. Given the lack of annotations and parameter documentation, this description is far from complete for an agent to invoke the tool confidently.

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

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

The schema has one parameter, session_name, with no description, and schema coverage is 0%. The description fails to explain what this parameter means or how it affects the call. An agent has no clue about the parameter's purpose or valid values.

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

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

The description states a clear action and resource: 'List Grafana alert rules.' However, it essentially restates the tool name, which already includes 'grafana' and 'alerts'. It does not differentiate from siblings like obs_grafana_datasources beyond the explicit resource, but that is minimal.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention any context, prerequisites, or exclusions. The description provides zero direction for an agent deciding between this and the many other obs_* 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, the description must carry behavioral disclosure. 'List' implies a read-only operation, but the description does not state whether a connection/session is required, whether it returns only the current session's datasources, or any other 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 short sentence with no filler; the action and resource are front-loaded. This is appropriately concise for such a simple tool.

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

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

The tool is simple and has an output schema, so return values need not be documented. However, the description omits any mention of session_name, connection prerequisites, or when this tool is the right choice, leaving meaningful 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?

The only parameter, session_name, has no description in the schema (0% coverage) and is not mentioned in the tool description. The title and default value offer minimal clues, but the description adds no meaning to help an agent decide whether to pass it.

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

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

The description uses the specific verb 'List' and the resource 'Grafana datasources,' making the tool's primary function unambiguous. It does not explicitly contrast with sibling tools, but the resource name is distinct enough from obs_grafana_alerts and the query tools.

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

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

There is no guidance about when to call this tool rather than obs_grafana_alerts, obs_query_metrics, or other siblings, and no mention of prerequisites such as an active session. The agent must infer the tool's niche solely from its name.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Run a LogQL query' without stating whether it is read-only, what error behavior occurs, rate limits, or the shape of the response. The lack of any such context leaves the agent uninformed about side effects and operational constraints.

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

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

The description is a single, focused sentence with a helpful example. It is front-loaded with the primary purpose and avoids unnecessary verbosity. The conciseness is appropriate, though it sacrifices depth for brevity.

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 is minimal and does not cover usage context, expected output (despite having an output schema), or operational details. For a tool with three parameters and several siblings, this is inadequate for an agent to use it correctly without further investigation.

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

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

Schema description coverage is 0%, so the description must compensate. It illustrates the 'query' parameter with an example but says nothing about 'limit' or 'session_name'. The schema provides defaults but no semantic explanation, and the description fails to add meaning beyond the bare parameter names.

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

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

The description clearly states the action (run a LogQL query) and provides an example. It implicitly targets log data, distinguishing it from metrics or traces siblings like obs_query_metrics and obs_search_traces. The verb-resource pairing is specific and 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?

No guidance is given on when to use this tool versus alternatives. It does not mention exclusions, prerequisites, or comparison with obs_query_metrics or obs_search_traces. The agent is left to infer the intended use case from the LogQL mention.

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 alone must convey behavior. It only mentions 'instant' but does not disclose potential side effects, authentication requirements, or error handling. It does not clarify whether a session must be established first or what happens on invalid queries.

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 an example, which is concise and immediately understandable. However, it could be slightly more informative 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?

Given the presence of connection-related sibling tools, the description lacks essential context about session management. It also does not mention what the output looks like, despite having an output schema. An agent might not know if a connection is required before calling this tool.

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

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

The description explains the `query` parameter with an example, but the `session_name` parameter is entirely unexplained. Since the schema provides no descriptions either, the agent is left guessing about session_name's purpose and relationship to the connection tools.

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

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

The description clearly states the action ('Run an instant PromQL query') and provides a concrete example, making the purpose unambiguous. It also differentiates from sibling tools like obs_query_logs and obs_get_trace by focusing on metrics queries.

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

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

No guidance is given on when to use this tool versus alternatives like obs_query_logs or obs_get_trace. There is no mention of prerequisites such as needing an active connection (given the sibling obs_connect/obs_disconnect) or when this is the appropriate choice.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only states 'Search Tempo traces' without mentioning read-only nature, pagination, rate limits, or any side effects. It doesn't even explicitly say it's a read operation, though 'search' implies it. This is a significant gap for a tool with no annotation coverage.

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

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

The description is very concise: one sentence plus an example. It's front-loaded with the action and the example is practical. There's no wasted text, though the brevity borders on under-specification rather than efficient completeness.

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

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

Despite having an output schema, the description is incomplete for a search tool with three parameters. It doesn't explain the purpose of 'limit' or 'session_name', nor any usage prerequisites or behavior expectations. An agent would have to guess at the semantics of these parameters, making the tool risky to invoke correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It gives an example for the 'tags' parameter, which is useful, but does not explain 'limit' or 'session_name' at all. With three parameters and only one hinted at, the description adds minimal value beyond the raw schema.

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

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

The description clearly states the action ('Search Tempo traces') and resource, so an agent knows what it does. However, it doesn't differentiate from sibling tools like obs_get_trace, which might retrieve a single trace, or obs_query_logs for logs. The purpose is clear but not scoped against alternatives.

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

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

No guidance is given on when to use this tool versus alternatives such as obs_get_trace or obs_query_logs. The example provided ('tags example') is about parameter format, not usage context. The agent is left to infer when to use it.

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 convey behavioral traits. It only states the operation ('List') and the resource, but does not explicitly state that this is a read-only operation, whether authentication or prerequisites are required, or any potential side effects. Since 'List' strongly implies a non-mutating query, this is not misleading, but the description adds no behavioral depth beyond the bare 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 a single, well-formed sentence: 'List configured observability sessions.' It is front-loaded with the verb and resource, contains no extraneous words, and earns its place entirely. Nothing could be removed without losing meaning.

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

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

For a zero-parameter tool with an output schema, the description is largely complete. It clearly states the tool's function. The phrase 'configured observability sessions' implies that sessions are set up elsewhere (e.g., via obs_connect), giving context about the tool's role in the session lifecycle. However, it does not explicitly note that this is a read-only status check, which would be a minor completeness gap given the absence of 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?

The tool has zero parameters, and the schema is an empty object. There are no parameter semantics to explain. Per the rubric, a 0-parameter tool gets a baseline of 4 because the description does not need to compensate for missing parameter documentation. The description correctly matches the schema's simplicity.

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 ('List') and a specific resource ('configured observability sessions'). It clearly distinguishes itself from siblings: obs_connect/obs_disconnect handle connection lifecycle, obs_query_* and obs_error_rate handle data retrieval, obs_grafana_* handle Grafana resources, and obs_annotate handles annotations. No ambiguity about what this tool does.

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

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

The description provides no guidance on when to use this tool versus its siblings. It does not mention that this should be used to check which sessions are configured before connecting, nor does it exclude any alternatives. There are no prerequisites, no explicit 'use this when' or 'instead of' statements. The usage context is entirely left to inference from the name and purpose description.

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