Opservo

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description adds the scoping constraint that results come only from the web server configuration (so non-web servers may yield nothing), which is modest added value but no detail on permissions, rate limits, or result shape.

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 with zero filler, front-loading both the resource (domains) and the secondary payload (SSL expiry days). Nothing is wasted and nothing important is buried.

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

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

For a one-parameter read tool with full annotation coverage and an output schema that already documents the return shape, the description supplies enough to call it correctly. The only shortfall is the absence of any routing guidance among the many sibling read tools.

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

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

Schema description coverage is 100% for the single agent_id parameter, so the baseline is 3. The description's 'one server' wording corroborates the schema's 'server/agent UUID' semantics but adds no additional format or constraint detail.

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 ('Returns') plus a precisely bounded resource: the domains in one server's web server configuration and each certificate's days-to-expiry. That resource is inherently distinct from siblings like get_services, get_server_overview, or get_log_summary, so an agent can route without opening any 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?

The phrase 'one server's web server configuration' implies the per-agent query model, but there is no explicit when-to-use, no when-not-to-use, and no mention of any alternative tool despite eight siblings. The agent is left to infer that this is the domain/SSL-specific view.

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?

Annotations already declare the tool as read-only, idempotent, non-destructive, and closed-world. The description adds no further behavioral traits such as auth requirements, rate limits, or performance characteristics, but it does provide clarity on the correlated nature of the output. With rich annotations, the bar is lower, and this is adequate.

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-structured sentence that front-loads the core action and lists relevant event types without any wasted words. Every element contributes to understanding the tool's scope.

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 an output schema and comprehensive annotations, the description is nearly complete for the tool's purpose. It could be improved by explicitly noting when to use it over related tools, but it is otherwise sufficient for correct invocation.

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

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

Schema description coverage is 100%, and both parameters (agent_id, hours) are fully documented in the schema. The description does not add any parameter meaning, so the baseline 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 names a specific verb ('Returns') and resource ('time-ordered list of correlated events on one server'), and enumerates the event types it captures. It is clear and detailed, but it does not explicitly distinguish itself from siblings like get_log_summary or get_recommendations.

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, nor any prerequisites or exclusions. The description only states what it returns, leaving the agent to infer 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?

Annotations already declare readOnly, idempotent, non-destructive and closed-world behavior, so the safety profile is covered. The description adds genuinely new behavior: the type-mismatch error path for non-Kubernetes agents and the specific shape of diagnostic data returned (pod reasons, exit codes, recent log lines).

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

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

Front-loaded with the core operation, followed by a dense enumeration of returned fields and then the scoping caveat. It is a single long sentence plus a short one; every clause carries information, though the long enumeration borders on 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?

An output schema exists, so return values are already covered structurally, yet the description still previews the key contents in a useful way. The error-path disclosure closes the main remaining gap for a single-parameter 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?

With only one parameter at 100% schema coverage, the schema already fully documents agent_id. The description's phrase 'one Kubernetes cluster connected to Opservo' implies the id selects a cluster but adds no syntax or constraints beyond the schema, so the baseline of 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 ('Returns the state of one Kubernetes cluster') and then enumerates the concrete contents (version, node conditions, workloads, problem pods, warning events). This clearly distinguishes it from siblings like get_server_overview and get_services, so an agent can route without opening other 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?

Explicitly scopes the tool: 'Answers only for a cluster (kind kubernetes); a Linux server returns an error saying so' tells the agent when this call will succeed versus fail. It does not, however, name the alternative tool to use for Linux servers, leaving that inference to the agent.

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?

Annotations already establish the safety profile (readOnlyHint, idempotentHint, destructiveHint=false), so the bar is lower and the description still adds real behavioral context: the data is AI-written, scoped to a one-hour window, limited to five patterns, and covers specific log sources (nginx, Apache, Laravel, Docker, PM2, systemd). It does not mention pagination or freshness/caching, which keeps it from a 5.

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

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

It is a single dense sentence, but front-loaded with the core purpose ('Returns the latest AI-written summary of one server's logs') before the pattern-window detail. Every clause carries information, though the trailing parenthetical log-source list and count/timestamp clause make it a run-on that could have been split for readability.

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?

An output schema exists, so return formatting needn't be restated, and the description covers scope (one server), time window (last hour), and volume (five patterns). Since this is a read-only, single-parameter tool, little else is required, though a note on how fresh the AI summary is would complete it.

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 agent_id parameter is fully documented as 'the server/agent UUID to query'. The description reinforces the one-server scope but adds no format, constraint, or validation detail beyond the schema, so the 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 a specific verb+resource ('Returns the latest AI-written summary of one server's logs') and enumerates the exact payload: five most frequent log patterns from the last hour, with counts and last-seen timestamps. This is clearly distinguishable from siblings like get_server_overview or get_incident_timeline, which cover different resources.

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: an agent can infer this is the tool for 'what is happening in a server's logs right now', and the 'last hour' window narrows the intent. However, it never states when to prefer this over get_incident_timeline or get_server_overview, nor any exclusion conditions, so routing must be inferred.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds genuinely useful behavioral context beyond that: the feed aggregates four command sources and is sorted newest to oldest, telling the agent what population and ordering to expect.

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

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

A single front-loaded sentence that moves from purpose to scope to ordering to returned fields with no filler. Slightly run-on with the parenthetical source list, but every clause earns its place.

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

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

An output schema exists, so the description need not explain return values, and annotations cover the safety profile. Purpose, scope, ordering and cardinality hints are present; the only gap is explicit routing guidance versus sibling history/log tools.

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

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

Schema description coverage is 100% for both parameters (agent_id UUID, limit 1-50 default 20), so the schema already carries full parameter meaning. The description adds nothing about parameter behavior, and per the baseline for high coverage a 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 (Returns) and resource (commands recently run on one server), plus the scope of what appears (terminal, quick actions, approved fixes, automation) and ordering. This clearly separates it from siblings like get_log_summary and get_incident_timeline without needing to name them.

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

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

Usage is only implied: an agent can infer this is the tool for command history on a given agent, but there is no explicit when-to-use, when-not-to-use, or pointer to alternatives such as get_log_summary or get_incident_timeline when a different view of activity is needed.

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?

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered. The description adds genuine behavioral context beyond that: only *open* issues are returned, results are ordered by severity, and each item carries a plain-English description plus a suggested fix.

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 that front-loads the resource, then the ordering, then the filtering. No redundant restatement of the title and nothing an agent must wade through.

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?

An output schema exists, so return-value details need not be spelled out, and the description still conveys what each item contains. Coverage is slightly short on situational routing versus the read-heavy siblings, but nothing needed to invoke the tool correctly 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 description coverage is 100%, so both agent_id and the severity enum are fully documented in the schema itself. The description's note that results can be narrowed to a single severity adds marginal value over the schema's 'Optional: only return recommendations at this severity'.

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: returns open issues detected on one server, ranked by severity, each with a description and suggested fix. The scope (single server, open issues only) is precise enough to separate it from list_agents or get_log_summary, though no sibling is named explicitly.

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

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

Implied usage comes through the scoping ('on one server') and the optional severity filter, but there is no statement of when to prefer this over get_server_overview or get_incident_timeline, nor any prerequisite guidance. Adequate but leaves the routing decision to inference.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered by structured data. The description adds scope-of-return context but nothing beyond annotations on behavior — no indication of snapshot freshness, caching, cost, or permissions needed to query a remote 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?

A single front-loaded sentence with no filler; the return contents are listed compactly. The enumeration is long but each item is genuinely selective information, so little 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?

An output schema exists, so the return-shape enumeration is largely reinforcing rather than required, and annotations carry the safety profile. The remaining gap is routing guidance: nothing tells the agent when to prefer this over get_kubernetes_snapshot, get_services, or get_log_summary.

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?

Only one parameter (agent_id) exists and the schema documents it at 100% coverage ('The server/agent UUID to query.'). The description adds no additional parameter semantics, so the schema-description baseline of 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 (get) and resource (one server's overview) and itemizes exactly what the snapshot contains — CPU %, load average, core count, memory %, per-mount disk usage, uptime, top-5 CPU processes, and service/app counts. This distinguishes it in substance from siblings like get_kubernetes_snapshot or get_services, though it never explicitly contrasts itself with them.

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

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

There is no explicit when-to-use or when-not-to-use statement. Usage is only implied by the enumerated contents (reach for this when you need a quick system-health snapshot of a single server), and the closely related siblings get_kubernetes_snapshot, get_services, and get_recommendations are not addressed.

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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds that results include both detection and running state across multiple service managers, which is useful context, but it says nothing about behavior when the agent is unknown, staleness of detection, or result volume.

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 service-manager enumeration placed inline rather than padding out extra sentences. Zero waste.

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?

An output schema exists, so return-value structure need not be re-explained, and the read-only annotations cover safety. For a simple one-param read tool this is nearly complete; only failure modes and staleness of detection are left 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 description coverage is 100% for the single agent_id parameter, so the schema already carries the semantics. The description's 'on one server' reinforces the single-server scope but adds no format or constraint detail beyond the schema. 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 (returns) and resource (services detected on one server), and enumerates the concrete sources covered: systemd units, Docker containers, PM2 processes. It also names the payload (running status). It does not explicitly distinguish itself from siblings like get_kubernetes_snapshot, but 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?

There is no when-to-use guidance, no exclusions, and no mention of alternatives despite related siblings such as get_server_overview and get_kubernetes_snapshot. The only usage signal is the implied 'one server' scoping, which comes from the schema rather than the description.

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

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

Annotations already declare readOnly, idempotent and non-destructive, so the safety profile is covered. The description adds real context beyond that: the exact attributes returned (agent_id, kind, hostname, display name, online status) and the filtering rule that archived servers are excluded. Pagination or result-size behavior is not mentioned.

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, zero filler, with the core purpose front-loaded and the archived-server caveat placed last where it belongs. 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?

An output schema exists, so return values need not be explained, yet the prose field list makes the result self-describing anyway. For a zero-parameter, read-only listing tool, nothing an agent needs in order to call it correctly 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?

The tool takes zero parameters, so there is no parameter semantics to document and the baseline is 4. The description's field list describes the output shape rather than any input, which is appropriate and adds no confusion.

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 ('Lists the servers and Kubernetes clusters in the signed-in Opservo workspace') and enumerates the fields returned, so the agent knows exactly what the call yields. The plural, whole-workspace scope implicitly separates it from the singular get_* siblings (get_server_overview, get_kubernetes_snapshot), but no sibling is named explicitly.

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

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

Usage is only implied: the description conveys that this is the enumeration entry point, and the note 'Archived servers are left out' hints at scoping. There is no explicit when-to-use, when-not-to-use, or pointer to get_server_overview for deeper per-server detail.

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