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

With no annotations, the description carries the full burden, and it usefully discloses that the tool is deprecated and internally uses the deprecated sdv.databroker.v1.ListMetadata RPC. It also clarifies the count-only behavioral scope. It does not discuss error behavior for invalid branches or empty results, but for a simple read-only count tool the key operational caveat is surfaced.

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

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

The description is front-loaded with the core purpose, followed by the use case, deprecation warning, and parameter details. The deprecation is mentioned twice (in the bracket and the note), a small redundancy, but every other sentence 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?

Given that an output schema exists and the tool is a simple count operation, the description covers purpose, parameters, and deprecation adequately. It omits exact empty-result or error behavior, but those are low-stakes for this tool and the structured data partially compensates.

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 provides no descriptions, so the description must compensate, and it does by explaining branch as a VSS path with examples and query as an optional substring. It adds meaning beyond the raw schema fields, though it could be more precise about matching semantics and default handling.

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 plainly states that the tool counts signals under a VSS branch, using a specific verb and resource. It also contrasts itself with list_signals by saying it 'returns only the count', so an agent can distinguish it from the most similar sibling without opening 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?

It explicitly indicates this tool is useful for 'quickly checking how many signals exist without fetching details', which tells the agent when to choose it over list_signals. It does not enumerate all exclusion cases, but the count-only purpose is a clear selection signal.

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 behavioral disclosure burden. It clearly communicates that this is a read operation ('Get the current value'), but it does not mention error behavior, whether the value reflects live/updated data, or any side effects. It is adequate for a simple getter but leaves some behavioral details unspecified.

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 compact: it opens with the API context and purpose, then gives an 'Args' section that directly maps to the schema. Every sentence adds value, and the example paths are useful without adding verbosity.

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

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

This is a low-complexity tool with one parameter and an output schema, so the description does not need to explain return values. It covers the input semantics adequately. It loses one point because it does not explicitly guide the agent on when to choose this over the closely related get_signals 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 0%, so the description must compensate for the schema's lack of parameter guidance. It does so well by explaining that 'path' is a VSS signal path and giving two realistic examples. For the single required parameter, this provides enough semantic context for an agent to construct a valid call.

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 states a specific verb ('Get'), a specific resource ('current value of a single VSS vehicle signal'), and includes concrete path examples. It clearly distinguishes itself from the sibling get_signals by emphasizing it retrieves a single signal rather than multiple.

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 makes it clear the tool operates on a single VSS signal path, which implies it should be used instead of get_signals when only one value is needed. However, it does not explicitly state when-not-to-use it or name alternative tools, so usage guidance is implied rather than explicit.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It clearly communicates a read-only, batch-fetching behavior ('Get current values of multiple signals'). It does not discuss error behavior or authorization, but for a simple read operation this is acceptable.

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

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

The description is short, front-loaded with the API context, and every sentence adds value. The Args section is minimal and directly tied to the single parameter, with no redundant content.

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

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

This is a simple one-parameter batch-read tool with an output schema available, so the description does not need to explain return values. The provided scope, parameter semantics, and batch behavior are sufficient for an agent to call it 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?

The schema provides only the parameter name 'paths' with 0% description coverage, so the description must compensate. It does so effectively by explaining that paths is a list of VSS signal paths and giving concrete examples, making the parameter usage unambiguous.

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 ('Get current values') and a clearly identified resource ('multiple VSS vehicle signals at once'). It directly distinguishes itself from the sibling get_signal by emphasizing the batch nature, so an agent can tell them apart.

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 'multiple VSS vehicle signals at once' clearly implies this tool is for batch reads rather than single-signal reads, which differentiates it from get_signal. It does not explicitly name alternatives or exclusion criteria, but the usage context is sufficiently clear.

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?

Even though no annotations are provided, the description discloses the deprecated status, the underlying deprecated sdv.databroker.v1 VAL.Get RPC with View.TARGET_VALUE, and the semantic meaning of target values. This goes beyond a simple action statement.

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 well-structured: purpose first, then a clarifying contrast, then a deprecation note, then the argument detail. There is minor redundancy in mentioning deprecation twice, but each part serves a clear informative 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?

For a single-parameter tool with an output schema, the description covers the core need: what the tool does, how to invoke it, and how it differs from siblings. It does not explain error behavior, but for a simple read-like operation with output schema available, it is sufficiently complete.

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

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

Schema coverage is 0%, so the description carries the burden of explaining the parameter. It defines 'paths' as a list of VSS signal paths and provides a concrete example, adding meaningful semantic context beyond the schema's bare 'Paths' title.

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 'Get the target (desired) values of actuator signals' with a specific verb and resource. It also distinguishes itself from get_signal by explicitly contrasting target values against current (sensed) values, so an agent can tell them apart.

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 explicit guidance: it names get_signal as the source for current values and recommends the Kuksa V2 Actuate flow (set_signal/get_signal) for reading actuation targets when possible. This clearly routes the agent to alternatives.

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

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

No annotations are provided, so the description carries the behavioral burden. It discloses that the tool is deprecated and internally uses the deprecated sdv.databroker.v1 VAL.Get RPC, which is valuable. However, it does not describe error behavior, side effects, or operational constraints beyond the read-only implication of 'Get'.

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

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

The description is compact and front-loaded with the core purpose, then adds a deprecation note, an alternative source for the same information, and an Args section. Every sentence contributes meaningful information, and none of it merely repeats the schema.

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

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

For a single-parameter read tool with an output schema available, the description covers the tool's purpose, when it is useful, its deprecated status, an alternative, and the required parameter. An agent has enough information to call it correctly without significant ambiguity.

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 coverage is 0% and the schema only says 'Paths' as an array of strings. The description compensates by defining 'paths' as a list of VSS signal paths and providing realistic examples, which gives an agent the semantic information needed to construct valid input. It could add constraints like maximum length or invalid-path behavior, but the examples are sufficient for normal use.

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

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

The description states a specific verb and resource: 'Get the data types of one or more VSS signals.' It also gives concrete example paths and notes that the tool is deprecated and that equivalent data type information is available via list_signals, which helps an agent distinguish it from related sibling 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?

It explains that the tool is useful for determining how to interpret or set a signal value, and explicitly mentions that list_signals also provides data type information. It does not fully spell out 'use list_signals instead' or hard when-not-to-use conditions, but the deprecation notice and alternative reference provide clear guiding 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?

With no annotations, the description carries the full disclosure burden and does so well: it discloses that the tool internally uses the deprecated sdv.databroker.v1.ListMetadata RPC, states that query matching is a case-insensitive substring on the signal path, and describes default scope behavior. It stops short of edge-case behavior such as errors on invalid branch paths, but covers the key behavioral facts.

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 purpose and deprecation in the first line, followed by usage rules and an Args reference. There is slight redundancy — the prose usage instructions essentially restate what the Args section repeats — but no sentence is wasted overall.

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 two optional parameters, an existing output schema (so return values need not be explained), and no annotations, the description covers purpose, filtering semantics, defaults, deprecation, and alternatives. The only notable omission is behavior on invalid branch paths, which is minor for a list/discovery 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 0%, and the description fully compensates with an Args section that explains branch as a VSS path with concrete examples ('Vehicle.Cabin') and query as a case-insensitive substring with examples ('Speed', 'Temperature'). This adds real meaning beyond the schema's bare titles and defaults.

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 first sentence states a specific verb and resource — 'List signals and their metadata under a given VSS branch' — with an explicit API tag. The deprecation header and the note preferring get_signal/get_signals for known paths clearly separate it from sibling tools in the same signal domain.

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?

Explicit when-to-use guidance: 'Prefer browsing signals via get_signal / get_signals with known paths when possible' names the alternative and the condition that selects it. It also explains both usage knobs (branch scoping, query filtering) and documents the default full-tree behavior when both are empty.

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 behavior disclosure. It clearly communicates that this is a write operation that sets the current value as reported by a sensor/provider and feeds it into the databroker. It stops short of describing side effects, error conditions, or authorization requirements, but core semantics are transparent.

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

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

The description is compact and well-structured: the core operation is front-loaded, the differentiator from a sibling is stated next, and the argument documentation is concise. Every sentence contributes information not otherwise available in the schema.

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

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

For a three-parameter tool with no annotations, the description covers the operation, the role, the distinction from set_signal, the concrete use case, and all parameters. Since an output schema exists, return-value details are not required from the description. Nothing essential is missing for correct selection and 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 0%, so the description must compensate. It does: path is defined as a VSS signal path with an example, value is defined as 'the current value to publish', and datatype is fully enumerated with all accepted type strings. This fully equips the agent to supply correct parameter 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 opens with 'Publish a current value for a signal (provider role)', which names a specific verb, resource, and role. It also explicitly contrasts with set_signal by distinguishing 'current value' from 'target', making the tool's purpose unmistakable among siblings.

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

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

The description directly says 'Unlike set_signal which sets the *target* for an actuator, publish_value directly sets the *current* value' and instructs 'Use this when you are acting as a data provider feeding sensor readings into the databroker.' This gives explicit when-to-use guidance and names the alternative.

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

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

No annotations are provided, so the description carries the behavioral transparency burden. It discloses that the tool uses the deprecated sdv.databroker.v1 GetServerInfo RPC and flags deprecation, but it does not explicitly state whether the call is read-only or describe failure behavior.

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

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

The description is two sentences with no wasted words. The main purpose is front-loaded, and the deprecation note adds meaningful context without bloating the text.

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 complete. It explains what the tool does, identifies the underlying API, and clearly warns about deprecation.

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, so the default baseline of 4 applies. The description does not need to elaborate on parameters because none exist.

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 action and resource: 'Get information about the connected Kuksa Databroker server.' This clearly distinguishes the tool from the signal-focused sibling tools such as get_signals and set_signal.

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 tool's purpose is clear: it is a standalone server-info query with no parameters, so there is no ambiguity about when to call it. The deprecation note provides important usage context, though it does not explicitly name a replacement or state when not 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?

With no annotations provided, the description carries the behavioral disclosure burden. It usefully reveals the internal routing and fallback between kuksa.val.v2 and sdv.databroker.v1, and 'Set' implies mutation. But it does not address permission requirements, error behavior, persistence, or physical side effects of writing an actuator value.

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

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

The description is compact and front-loaded: one purpose sentence, one internal-behavior sentence, then a clean Args list. There is no filler and every sentence adds value.

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 three-parameter write tool, the description covers objective, execution path, and all parameters, and an output schema exists to describe return values. It is not perfect only because it omits explicit guidance on selecting this tool over publish_value and does not state operational prerequisites for the Kuksa/databroker backends.

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 fully define parameters. It does: path gets a concrete VSS example, value is explained as a string representation, and datatype gets all valid values enumerated. This constitutes complete, useful parameter documentation.

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 opens with a specific verb-resource statement: 'Set the target value of an actuator or attribute signal.' It clearly identifies the resource type and distinguishes itself from read-oriented siblings like get_signal, list_signals, and get_target_values.

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: this tool is for writing target values, while the sibling tools are mostly read operations. However, it never explicitly says when to prefer set_signal over the similar publish_value sibling, nor does it state prerequisites or exclusions.

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