Koot by Datakoot

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

Annotations already cover readOnly, idempotent, open-world and non-destructive. The description adds behavioral value beyond them: it discloses the scope constraint (US public companies only) and that 8-K material events are flagged, which hints at the curation of results.

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 tight sentences: the capability and its contents are front-loaded, followed by the required input. No filler or 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?

An output schema exists, so return values need not be documented, yet the description still summarizes them usefully. With one 100%-covered parameter and full annotations, it is nearly complete; the only gap is explicit routing guidance among the brief_* siblings.

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

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

Schema coverage is 100% with a single well-described parameter, so the schema carries the load. The description's 'ticker, name or CIK' merely restates the parameter description rather than adding new meaning; 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 ('briefs') and resource ('US public company') and enumerates what the brief contains (SEC profile, filings, insider trades, financials). The 'US public' scoping and the entity type distinguish it from brief_domain, brief_place and brief_stack 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?

Usage is implied by the 'One call briefs you' framing and the sibling family, but there is no explicit when-to-use or when-not guidance. It tells you the input formats but not when to choose this over brief_domain or koot_watch.

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, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds genuinely useful behavioral context by disclosing which external data sources the single call touches (WHOIS/DNS, SPF/DKIM/DMARC records, CT logs), which tells the agent to expect external lookups and a multi-source aggregate.

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 leads with the action and scope, then enumerates coverage compactly. No filler, no repetition of the title, and 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 return-value documentation is not required, and the description adequately signals the breadth of what one call returns. It is slightly thin on edge cases (invalid domains, partial failures, cost of a consolidated multi-source call), but complete enough for a one-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?

Schema description coverage is 100% and the single 'domain' parameter already carries a format example ('stripe.com'), so the schema does the heavy lifting. The description adds no further input semantics (e.g., bare domain vs URL vs subdomain handling), 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?

States a specific verb ('checks') and resource ('domain'), then enumerates the exact data categories returned: registration/DNS, email security, tech stack, and subdomain CT logs. The domain focus distinguishes it from brief_company and brief_place, though it does not explicitly contrast itself with brief_stack, which also covers tech stack.

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?

'One call checks a domain' implies this is the consolidated alternative to running several narrow lookups, which hints at when to reach for it. However, there is no explicit when-to-use statement, no exclusions, and no routing advice against the overlapping brief_stack sibling, leaving the selection 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?

The annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is fully covered elsewhere. The description adds the useful behavioral note that everything arrives in a single call (implying no chained requests), but says nothing about latency, rate limits, failure modes for unknown places, or data freshness beyond what annotations/output schema provide.

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 the payload ('One call briefs you on a US place') stated first and the contents enumerated after. The content list is long but each item earns its place by telling the agent what it will receive without opening the output schema.

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

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

For a one-parameter read tool with a full output schema and complete annotations, the description is nearly sufficient: it states scope, subject and return contents. Only edge-case behavior (invalid/ambiguous or non-US places) is 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% and there is only one parameter, so the baseline is 3. The description adds genuine meaning beyond the schema by scoping the argument to US places, a constraint the schema only implies through its 'Harrisburg, PA' example – useful for rejecting non-US inputs.

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 ('briefs you') and resource ('a US place') and enumerates exactly what the briefing contains: conditions, forecast, state alerts, earthquakes and elevation. This differentiates it from siblings like brief_company, brief_domain and brief_stack by subject matter, though it never names those siblings 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 implied by 'One call briefs you on a US place' – an agent can infer this is the consolidated way to get place context rather than aggregating weather/quake sources separately. However, there is no explicit when-to-use/when-not or comparison against the brief_* siblings or the koot_watch family.

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, openWorldHint, and destructiveHint=false, so safety is covered. The description adds real substance beyond that: live exploitation signal via CISA KEV, likelihood via EPSS, abandoned/deprecated detection, and a ranked fix-first ordering of results. It still doesn't mention auth, rate limits, or freshness of the vulnerability 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?

Three sentences, front-loaded with the core question and followed by what is checked and what is returned. No filler; each clause carries distinct information.

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

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

With an output schema present, return values need no explanation, and annotations cover the safety profile. The description supplies the remaining needed context: input flexibility, the prioritization model, and the exploitation signals used.

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 schema already documents manifest, packages, and ecosystem, including the name@version string form and the default npm ecosystem. The description's mention of a package list or pasted manifest only restates the schema, adding no format or precedence details. 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 opening line states the exact question the tool answers ('is my project safe?') and the resource it operates on (a package stack), then enumerates the concrete checks performed. This clearly separates it from brief_company, brief_domain, and brief_place, which cover entirely 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?

It signals the use case ('One call answers...') and states both accepted inputs (a package list or a pasted package.json / requirements.txt), which tells an agent when this tool fits. It stops short of naming when NOT to use it or pointing at the koot_watch/koot_unwatch siblings for ongoing monitoring.

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 flag destructiveHint=true and idempotentHint=true, but the description earns credit by specifying WHAT is destroyed: all: true 'stop and forget everything,' and stop_alerts only silences Slack/Discord alerts rather than removing the watch. That distinction between data deletion and notification muting is not derivable from the annotations alone.

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, front-loaded with the verb and resource, wasting no words. The inline colon-separated flag explanations are dense but readable; minor cost is slight run-on structure.

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 no explanation, and the destructive scope is covered. What remains missing is whether all: true is exclusive with packages/companies and what happens to a watch that was only alert-muted.

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% across 4 parameters, so the description carries the burden. It explains the semantics of all and stop_alerts well, but packages and companies are left entirely undefined (accepted identifier format, interaction with all: true), leaving half the parameters undocumented.

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

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

States a specific verb and resource ('stop watching packages or companies') and is clearly the inverse of the sibling koot_watch. The 'PRO.' prefix adds a tier marker but the core purpose is unambiguous without opening the schema.

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

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

It distinguishes two modes of use (all: true for full removal vs stop_alerts: true for muting notifications), which is genuine usage guidance. However it never says when to prefer unwatch over alternatives like koot_watches management, nor any prerequisites or exclusivity rules between the flags.

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?

Adds real behavior beyond the annotations: what is monitored, that only NEW exploited/likely-exploited vulns and new 8-K-flagged SEC filings are reported, and that notify_url triggers autonomous daily Slack/Discord posts. This complements openWorldHint/idempotentHint/destructiveHint rather than repeating them, though it omits auth/tier details beyond the 'PRO' label.

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-loads the PRO gating and the core action, then layers in reporting behavior and the notify_url option without redundant sentences. Every clause carries distinct information.

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

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

With annotations covering safety signals and an output schema handling return values, the description supplies the remaining context an agent needs: what gets watched, what gets reported, and the notification channel. Only edge cases like removing watches or tier limits are left unstated.

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

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

Schema description coverage is 100%, so all five parameters (manifest, packages, companies, ecosystem, notify_url) are already documented in the schema. The description reinforces purpose but adds little parameter-level syntax or format detail, matching the baseline-3 expectation when the schema does the heavy lifting.

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

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

States a specific verb and resource ('Tell Koot what to watch': packages and/or companies), and the additive behavior ('calling again adds to the list') cleanly separates it from the sibling list/unwatch tools (koot_watches, koot_unwatch). An agent can identify its role without opening the schema.

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

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

Gives clear context for use ('tell Koot what to watch once') and explicitly describes the accumulation behavior on repeat calls. It stops short of naming when-not or pointing at siblings like koot_unwatch for removal, so it is strong but not fully routing.

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=true, so the safety profile is covered. The description adds only the 'PRO' tier marker as behavioral context and says nothing about scope, freshness of results, or result volume. With no parameter or output explanation and an open-world read, this is thin.

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 fragments with no filler, which is structurally fine, but the brevity comes at the cost of substance rather than from trimming redundancy. The 'PRO.' prefix consumes the front-loaded position with tier metadata instead of 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?

An output schema exists, so return values need not be described. Still, for a zero-arg read tool sitting in a cluster of similarly named siblings (koot_watch, koot_unwatch, koot_whats_new, brief_*), the description does not supply enough context for confident tool selection.

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

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

The tool takes zero parameters and the input schema is an empty object at 100% coverage, so there is nothing for the description to document. Baseline 4 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 verb 'Lists' plus the resource 'what Koot is watching' gives a workable purpose, and the plural name hints it is the read counterpart to koot_watch/koot_unwatch. However, 'what Koot is watching' is never concretized (projects? domains? keywords?), and nothing distinguishes it from the sibling koot_whats_new. The '(Pro)' tag adds a tier marker, not clarity.

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

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

There is no when-to-use or when-not-to-use guidance, no mention of prerequisites, and no routing to or away from koot_watch, koot_unwatch, or koot_whats_new. The only hint is the 'PRO' prefix, which signals a tier gate but not a usage condition.

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

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

The description's "only what changed since the last check" explains the delta semantics, which is meaningful context beyond the annotations and accounts for why readOnlyHint is false and idempotentHint is false (a checkpoint advances on call). It does not disclose auth requirements, rate limits, or what happens on first call with no prior check.

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, front-loaded with the PRO marker and the trigger phrasing, then the scope of the delta. Slightly promotional ("Great to call...") but that clause carries genuine usage value rather than pure filler.

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

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

An output schema exists, so return values need not be described, and the annotations cover the safety/open-world profile. The description adequately covers trigger and delta scope; the only unstated prerequisite is that packages/companies must already be watched before this returns anything, which is only implied by "your watched".

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 nothing for the description to disambiguate and the baseline is 4. No parameter-level claims are made or needed.

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

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

States a specific verb+resource+scope: reports what changed since the last check, naming the exact content types (new exploited/likely-exploited issues in watched packages, new SEC filings from watched companies). It is distinguishable from the per-entity brief_* siblings by its delta-across-watches scope, though it never names those siblings 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?

"Great to call at the start of every session" gives a clear positive trigger condition for when to invoke this tool. It stops short of naming alternatives (e.g. brief_company/brief_stack for per-entity queries) or stating exclusions, so it is clear context without full routing guidance.

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