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 the distinction between course and system announcements, which is useful context, but does not explain pagination, filtering behavior, or any operational nuances beyond that.

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 carry the core purpose and a key usage hint with zero filler. The main action is front-loaded, making it easy for an agent to parse quickly.

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 are already documented, and annotations cover the read-only behavior. However, the description does not explicitly connect course nullability to system announcements, nor mention pagination via limit/offset, leaving some gaps for a tool with four parameters.

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 all parameters. It vaguely explains the purpose of course and announcement_id ('for detail') but leaves limit and offset entirely to inference. It also fails to clarify that omitting course returns system announcements, leaving the param semantics under-specified.

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 identifies the verb ('Read') and resource ('course or system announcements'), which is distinct enough from siblings like blackboard_courses or blackboard_grades. It does not explicitly name a sibling for differentiation, so it misses the top score, but the purpose 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 gives a concrete usage instruction: 'Provide course and announcement ID for detail,' which tells the agent how to get detailed announcements versus a general list. It does not mention alternatives or exclusions, but the context is clear for a simple read tool.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true, and destructiveHint=false, covering the safety profile. The description adds one genuinely useful behavioral note—'Permission-denied authoring fields are not bypassed'—which clarifies authorization behavior beyond what the annotations provide. However, it stops short of explaining what 'accessible' means in practice or how pagination and error cases behave.

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

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

Two sentences with the core purpose front-loaded and the security-relevant caveat placed second, with no filler or repetition of schema fields. The 'or' construction in the first sentence is slightly ambiguous, but the description is otherwise efficient and well ordered.

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 presence of an output schema covers return values and the rich annotations cover the safety profile, lowering the description's burden, yet critical operational details remain unstated: what value to pass for the required `course`, what `content_id` filters toward, and whether limit/offset paginate across assessments. A new agent would struggle to construct a correct first call without consulting external 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 mentions no parameters at all—course, limit, offset, and content_id receive no semantic explanation beyond their bare schema titles. The required `course` parameter's format and provenance (e.g., obtained from blackboard_courses) are left entirely to the agent to guess. With zero schema coverage, the description was obligated to compensate and did not.

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 and resource ('Discover assessments or read accessible assessment metadata'), which scopes the tool to assessment data and distinguishes it from sibling tools like blackboard_courses and blackboard_grades. The phrasing is clear enough for an agent to know what the tool operates on, though the 'Discover or read' construction leaves minor ambiguity about whether these are two distinct operation modes.

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 offers no guidance on when to choose this tool over alternatives such as blackboard_grades or blackboard_content, and names no exclusions or alternative tools. An agent must infer usage purely from the tool name and resource scope. The permission caveat hints at a limitation but provides no routing logic.

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. The description adds valuable context beyond those annotations by confirming it does not check in, fabricate proof, or change attendance, which prevents misuse for actions that an agent might otherwise associate with an attendance tool. No contradiction with annotations.

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 the primary action front-loaded and exclusions compactly stated in the second sentence. There is no filler, repetition of schema details, or unnecessary elaboration.

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 output schema exists and annotations cover the safety profile, but with five parameters and zero schema descriptions, the description leaves important invocation details undocumented, such as the required course field and how meeting_id filters the results. It is adequate for a high-level understanding but not fully complete for every intended call.

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 does not compensate. It never explains that course is required, how view and meeting_id relate, or what limit and offset control. The phrase 'attendance or class meetings' loosely maps to the view enum, but the agent is left to infer most parameter semantics from field names 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 description states a specific verb ('Read') and a clear resource ('recorded attendance or class meetings'), and the negative clause explicitly rules out check-in, proof fabrication, and attendance changes. This distinguishes it from sibling tools like blackboard_grades or blackboard_calendar by scope and behavior.

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 implies usage for reading attendance/meeting records and warns against expecting write behavior, but it does not name alternative tools or state explicit conditions for choosing this tool over siblings such as blackboard_courses or blackboard_calendar. The usage context is clear but not fully 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?

Annotations already establish readOnlyHint, idempotentHint, and non-destructive behavior. The description adds valuable behavioral context beyond those annotations: the 28-day range cap, the ISO date requirement for events, and the default-to-do-window behavior when no date arguments are supplied.

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 short sentences, each carrying a distinct and necessary fact, with no filler or repetition. It is appropriately front-loaded with the output categories and then states constraints. A leading verb would improve clarity, but the current size is well suited to the tool's complexity.

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 read-only tool with an output schema, rich annotations, and only five optional parameters, the description covers the most non-obvious invocation details: conditional date requirements, date range limits, and default behavior. The main remaining gap is not explicitly stating how the view enum values correspond to the listed output categories, but this is largely inferable.

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 parameter meaning. It does explain important semantics for since and until (ISO format, 28-day maximum range, default behavior when absent), but it leaves view mapping, limit, and offset semantics implicit rather than directly explained.

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 enumerates the resource types (deadlines, events, calendar definitions, or activity) and those align with the view enum, so an agent can infer this is a read/query tool for Blackboard calendar data. It lacks an explicit verb like 'get' or 'list', and it does not distinguish itself from sibling calendar-like tools, but the resource scope is reasonably clear.

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 concrete invocation guidance: events require ISO since/until, the date range must be 28 days or less, and omitting dates triggers Blackboard's default to-do window. However, it does not state when to prefer this tool over alternatives such as blackboard_dashboard, connects_events, or careers_calendar.

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, openWorldHint, idempotentHint, and non-destructive behavior. The description adds valuable context beyond these by explicitly stating the tool will not mark content complete or launch LTI/tests, which is a behavioral constraint an agent would not otherwise know. It also hints at traversal/pagination behavior with 'Traverse children for large courses'.

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

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

Two sentences with no filler. The core capabilities are front-loaded, followed by a single sentence of exclusions and a traversal hint. Every clause contributes to understanding the tool's behavior and boundaries.

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 read-only annotations, an output schema, and an enum-driven view parameter, the description covers the essential behaviors and exclusions. It is slightly incomplete on how `query` and `content_id` are used, but the overall picture — browse, search, list, traverse, no side effects — is sufficient for correct selection and basic 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 map the view enum to actions ('Browse ROOT/folder children' → children, 'inspect content' → item, 'search' → search, 'list links/attachments' → links/attachments) and implies limit/offset via 'Traverse children'. However, it does not explain `query`, `content_id`, or how they relate to specific views, leaving some parameters semantically under-specified.

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 specific verbs and resources: 'Browse ROOT/folder children', 'inspect content', 'search or list links/attachments'. This clearly distinguishes it from siblings like blackboard_courses (course list) and blackboard_grades/assessments (other course areas), and the explicit 'Does not mark content complete or launch LTI/tests' further delimits its scope.

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 gives clear context for when to use the tool: to browse, inspect, search, or list content items, and to traverse children for large courses. It also states exclusions (does not mark complete or launch LTI/tests), though it does not name specific alternative tools. This is strong but not fully explicit about when-not-to-use versus 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?

Annotations already cover read-only, idempotent, and non-destructive behavior. The description adds a valuable boundary condition with 'Restricted sections remain unavailable,' warning that results may be partial depending on access. This goes beyond the annotations without contradicting them.

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 efficient sentence with no filler, and the restricted-section caveat is packed in without bloating the text. It is concise and front-loaded, though it is a noun phrase rather than a complete imperative statement.

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 enough that the description plus annotations and output schema provide a workable definition. Still, it lacks guidance on identifying a specific course and does not help an agent choose between this and nearby sibling 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 0%, so the description carries the burden for parameter meaning. It maps several view options to prose, but it omits the 'membership' enum value and does not explain the required 'course' parameter format or the limit/offset behavior.

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 the resource (course) and enumerates the data areas it exposes: details, role, roster/instructors, timetable, tools, and progress. This makes the tool's scope reasonably distinct from siblings, though it lacks an explicit verb like 'retrieve' or 'get'.

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 listed views imply when to use this tool, such as retrieving a specific course's roster or schedule. However, there is no explicit guidance about alternatives like blackboard_courses or blackboard_content, 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 readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior, which fully cover the safety profile. The description adds a useful integration hint about returned IDs, but otherwise lists no additional behavioral details like pagination defaults or filter semantics beyond what annotations imply. This is acceptable given the rich annotations.

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 concise: two short sentences. The core purpose is front-loaded, and the second sentence adds high-value cross-tool guidance. Every word earns its place, with no repetition of what annotations or schema already convey.

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 an output schema and safety annotations, the description is incomplete for an agent to confidently invoke the tool because all six parameters are undocumented and the description does not clarify their purpose or constraints. The ID-preference note is helpful, but without parameter semantics the agent cannot distinguish, for example, 'term' from 'query' or know what 'available_only' controls.

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 carries the burden of explaining the six parameters. It does not explain what 'term', 'query', 'organizations', 'available_only', 'limit', or 'offset' mean. The name and defaults provide minimal inference, but the description itself adds zero parameter-level meaning, which is a major gap.

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 specific verbs 'List/search' and names the resource: 'enrolled courses or organizations.' This clearly distinguishes it as a collection-level discovery tool from singular siblings like blackboard_course, and the note about returned IDs being preferred for other Blackboard tools further clarifies its role.

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

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

The description provides clear context for when this tool's output is needed: 'Returned IDs are preferred for all other Blackboard tools.' This indicates the primary use case is to obtain course/organization IDs for downstream tool calls. However, it does not explicitly name alternatives or state when not to use this tool, such as when a specific course id is already known.

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 mark the tool as read-only, open-world, idempotent, and non-destructive. The description adds useful context by stating that the output is a 'bounded summary' spanning multiple domains, which sets expectations about scope and output size without contradicting the annotations.

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 front-loaded phrase of under fifteen words. It contains no filler, repetition, or unnecessary clauses, and every word contributes to defining 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 that the tool has no parameters, an output schema is present, and annotations cover the safety profile, the description names all included content domains and the bounded nature of the result. It is sufficient for invocation, though the exact meaning of 'bounded' could be slightly clearer.

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 100% schema description coverage, so there are no parameter semantics for the description to clarify. The 0-parameter baseline of 4 applies, and the description does not need to compensate for any schema gaps.

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 identifies the tool as an aggregate summary covering several specific Blackboard domains: identity, courses, to-do, activity, and messages. This clearly distinguishes it from the individual blackboard_* list tools, though it lacks an explicit verb like 'get' or 'return'.

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 term 'dashboard' and 'summary' imply use for a consolidated overview rather than detailed data retrieval, but there is no explicit when-to-use or when-not-to-use guidance and no named alternative tool. An agent must infer that detailed course or message data lives in sibling tools.

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

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

The phrase 'without posting or mutating read state' adds behavioral context beyond the annotations by clarifying that reading does not affect read/unread status. This is valuable because many messaging tools mark items as read on access. It is fully consistent with the readOnlyHint, idempotentHint, and destructiveHint annotations.

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

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

The description is a single sentence that front-loads the action ('Read') and the resource. Every word earns its place, and there is no redundancy or fluff. It is easy to parse and appropriately sized.

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 annotations and an output schema, the tool has six parameters and multiple views, and the description does not explain the navigation hierarchy among forums, messages, and replies or the roles of forum_id and message_id. This leaves significant gaps for an agent attempting to use the tool correctly, especially for multi-step discussion browsing.

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 lack of parameter documentation. It does not: the description provides no explanation of course, view, forum_id, message_id, limit, or offset, nor how the view enum values relate to forums, threads, and replies. An agent would have to guess how to construct even basic calls.

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 identifies a specific verb ('Read') and resource ('discussion forums, threads and replies'). It also explicitly distinguishes the tool from write operations by stating 'without posting or mutating read state.' This makes its purpose unambiguous and distinct from sibling tools like blackboard_messages.

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 establishes the context of use: retrieving discussion content in a read-only manner. It does not explicitly mention alternatives or when-not-to-use, but the context is clear enough that an agent can infer when to invoke it. No exclusionary guidance is present, but none is strictly required given the unique scope.

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 discloses meaningful behavior beyond the annotations: the file is generated, private, and local; overwrite and execution are disallowed; and the return payload is path, bytes, and SHA-256. This adds real context and does not contradict the annotations.

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 short, front-loaded sentences carry the full message: action first, constraints second, return value third. There is no filler or repetition.

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?

Operational details such as safety constraints, side effects, and return values are covered, and an output schema exists. The main gap is that the description does not explain how to obtain the three identifiers, though sibling tools and parameter naming make this reasonably inferable.

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 does not explain how course, content_id, and attachment_id relate or where these values come from. The parameter names and regex patterns hint at their purpose, but the description does not compensate for the missing schema 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 names a specific verb and resource: download an existing attachment to a generated private local file. It also states concrete limits (<=100 MiB) and the output format, making it easy to tell apart from other Blackboard read/list 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 clearly says when to use the tool: when you have an existing attachment identified by course, content_id, and attachment_id, and it is within the size limit. The 'No arbitrary URL/path, no overwrite or execution' clause provides useful negative boundaries, though it does not explicitly name an alternative tool.

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

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

Annotations already declare readOnlyHint and idempotentHint, but the description adds valuable context by emphasizing 'EXISTING attempts/feedback' and explicitly ruling out state-changing actions. This resolves ambiguity beyond what the annotations alone provide, with no contradiction.

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 first defines the output scope, and the second delivers the critical guardrail against misuse. Every word earns its place, and the key constraint 'EXISTING' is front-loaded.

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 and annotations cover the safety profile, so a detailed return specification is not required. However, the unannotated view enum and the relationship between column_id, attempt_id, and the various views remain under-specified, making the description minimally viable rather than fully 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 description coverage is 0%, and the description does not compensate by explaining any parameters. The nine-value view enum, limit/offset, column_id, and attempt_id are left entirely to inference from parameter names, which is a significant gap for a six-parameter tool.

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 the resource and scope: 'Visible grades and EXISTING attempts/feedback', and explicitly excludes starting tests, creating attempts, or submitting answers. This clearly distinguishes it from assessment-oriented sibling tools like blackboard_assessments even though that tool is not named.

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

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

The description tells the agent when to use the tool: whenever grade data, existing attempts, or feedback are needed. It also provides a clear when-not by saying it never starts tests or submits answers, though it stops short of naming the alternative tool for those actions.

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 known. The description adds value by noting 'visible membership' and 'no enrollment changes', but it does not disclose how view modes, group_id, or pagination affect behavior beyond what the schema already exposes.

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, front-loaded sentence with no filler. Every clause adds useful information: it names the verb, the resource scope, and the non-mutating guarantee.

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 output schema and annotations carry some of the burden, but with five parameters and zero schema documentation, the description is thin. It communicates the core purpose but leaves view-specific usage, group_id targeting, and pagination conventions mostly implicit, making it adequate but not fully 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 description coverage is 0%, so the description needed to compensate by explaining parameters like view, limit, offset, and group_id. It only provides high-level resource language ('groups, group sets, visible membership') that loosely maps to the view enum, but leaves the remaining parameter semantics entirely to the schema.

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

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

The description uses a specific verb, 'Read', and a specific resource, 'course groups, group sets and visible membership'. It also adds the scoping statement 'with no enrollment changes', which clearly distinguishes this as a read-only tool and separates it from potential write-oriented group 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?

The description gives clear context: use this tool to read course groups, group sets, and membership without affecting enrollments. It does not explicitly name alternatives among siblings like connects_groups or blackboard_courses, but the read-only scope and course-group vocabulary provide a clear 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 readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds value by explicitly stating 'Never sends messages or marks them read,' which clarifies the tool's non-mutating behavior beyond the generic annotation hints. It also reinforces the openWorldHint by framing the tool as reading existing data. No contradiction with annotations.

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 followed by a one-sentence disclaimer. It is front-loaded with the core purpose and adds only essential constraints. No wasted words.

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

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

The description is sufficient for a read-only list/retrieve tool, especially with the annotations covering safety and idempotency. The output schema exists, so return values don't need explanation. The main gap is that the description doesn't specify how the 'view' parameter changes the output or which combinations of parameters are allowed, but the output schema and enum values partially compensate. Overall complete enough for an agent to select and invoke safely.

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. The description explains that the tool reads messages/conversations and clarifies the 'view' dimension (summary, conversations, messages, participants) by naming them, which adds meaning beyond the raw enum. However, it doesn't explain how 'course', 'conversation_id', 'limit', and 'offset' interact semantically, so the agent still needs to infer some parameter relationships from the schema 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 tool reads existing messages/conversations, and explicitly disclaims sending messages or marking them read. The verb 'Read' plus resource 'messages/conversations' makes the purpose unambiguous. This also distinguishes it from potential sibling messaging tools (e.g., connects_chats) as a read-only Blackboard messages tool.

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

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

The description implies read-only usage and says what it never does, but it does not explicitly state when to use this vs alternatives such as blackboard_discussions or connects_chats. It gives a clear context (read-only Blackboard messages) but no exclusions beyond the disclaimers. It does not name alternative tools for sending messages or marking read, which an agent might infer are not covered by this tool.

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

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

The description adds a meaningful behavioral warning beyond the annotations: some views return page metadata rather than complete structured records, so the agent should not infer completion from them. This is valuable context that the readOnly/openWorld/idempotent annotations do not convey.

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: two sentences, no filler, and the key warning is placed second. It could be more informative without becoming verbose, but it earns its length.

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 optional one-parameter tool with a full enum, an output schema, and safety annotations, the description is nearly complete. The main gap is the lack of usage guidance, but the core read semantics and the important metadata caveat are present.

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 does not explain the 'view' parameter, its possible values, or how to choose among them. The enum in the schema is self-documenting to some degree, but the description adds no parameter-level meaning, so it fails to compensate for the missing 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 ('Read') and resource ('personal activity surfaces'), which distinguishes it from sibling tools focused on other domains like events, people, or courses. It does not explicitly differentiate from all siblings, but 'activity surfaces' is reasonably specific and the view enum further clarifies the scope.

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 alternatives such as connects_dashboard, connects_feed, or blackboard_activity. There is no mention of prerequisites, preferred contexts, or exclusions, so an agent must infer usage from the name and enum alone.

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 the user-facing specificity of not sending messages or changing read state, but does not reveal further behaviors such as pagination, auth requirements, or how views behave. No contradiction with annotations.

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 clean, front-loaded sentence with zero filler: the main action comes first, followed by explicit constraints. Every word 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?

Annotations and output schema cover safety and return structure, but the tool has four parameters with 0% schema description coverage and the description does not clarify parameter interactions, such as chat_id being needed for message/file/participant views. An agent would have to guess at invocation requirements, so the definition is not complete enough.

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 no parameter semantics. It does not explain the view enum values, when chat_id is required, or how limit/offset paginate, so the agent receives no extra meaning beyond raw schema names 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 description opens with a specific action and resource ('Read existing chat data') and immediately states what the tool cannot do (send messages or change read state). This makes its read-only purpose unmistakable and distinguishes it from any chat-mutation counterpart in the sibling set.

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 gives clear context: use for reading existing chat data, not for sending messages or altering read state. It stops short of naming a specific alternative for those write actions, so it is just below the explicit when/when-not/alternative bar.

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 and idempotentHint=true, so the safety profile is covered. The description adds the ID source but does not disclose behavior around pagination, the meaning of the section choices, or what each section returns. It provides no contradiction and some contextual value, hence a mid-range score.

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 concise sentence with no filler. The verb and resource are front-loaded, and every word adds 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?

Annotations are rich and an output schema exists, lessening the burden on the description. However, the description does not clarify that the 'section' parameter selects which part of the course to read or how limit/offset apply. It is adequate for basic invocation but leaves notable gaps.

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 bears responsibility for explaining parameters. It only clarifies that course_id comes from connects_courses, but says nothing about the 'section' enum, 'limit', or 'offset'. The enum values are somewhat self-explanatory, but pagination semantics and section selection are left 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?

The description uses a specific verb ('Read'), names the resource ('a Connects course section'), and identifies where the course ID comes from ('connects_courses'). This clearly distinguishes it from list-oriented siblings such as connects_courses and other connects_* 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?

The description implies a clear workflow: first obtain a course ID from connects_courses, then call connects_course to read a section. It does not explicitly contrast with siblings or state when not to use it, but the context is sufficient for an agent to infer appropriate usage.

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, and destructiveHint=false, so the safety profile is well covered. The description adds domain context about Connects versus Blackboard but no extra behavioral details such as pagination behavior or result ordering. Given the annotations, this is a neutral score.

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, purposeful sentences with no filler. The core operation is front-loaded, and the second sentence adds a useful routing qualifier without redundant detail.

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 read-only listing tool with two obvious pagination parameters and an existing output schema, the description plus annotations are largely sufficient. It could be slightly more explicit about when to prefer connects_courses over connects_course or blackboard_courses, but nothing critical 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 0%, and the description does not explain limit or offset at all. The parameter names, defaults, and constraints in the schema carry the meaning, but the description itself contributes no parameter-level value, falling short of what is needed when schema descriptions are absent.

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 ('List') and resource ('Connects courses'), immediately clarifying what the tool does. It also differentiates from Blackboard tools, helping the agent distinguish it from siblings like blackboard_courses and connects_course.

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 explicitly says to use Blackboard tools for LMS readings, assessments, and grades, which is a clear exclusion and points the agent to alternatives. It does not explicitly mention connectors like connects_course for detail views, but the list-oriented verb and the Blackboard routing note give adequate 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, openWorld, and non-destructive, so the description is not responsible for safety disclosure. The word 'personalized' adds minimal context about user-specific output, but there is no additional behavior detail such as whether login is required or how the discovery recommendations are produced. No contradiction with annotations exists.

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 short sentence with no filler. It front-loads the key domain ('IE Connects') and the general resource, though it leaves the ambiguous 'or' construction and lacks additional useful context.

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

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

For a simple read-only tool with one optional enum parameter and an output schema, the description is near the minimum viable level. It fails to clarify the meaning of the view parameter or how 'discovery recommendations' relates to the dashboard, so an agent will have partial information when selecting and invoking the tool.

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

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

Schema description coverage is 0%, so the description should compensate by explaining the view parameter; it does not mention view at all. The enum values are somewhat self-explanatory, and 'dashboard' matches one value, but the description does not clarify what categories, groups, people, events, or popular views return or how 'discovery recommendations' maps to them.

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 identifies the resource as the IE Connects dashboard or discovery recommendations and adds 'personalized,' but it is a noun phrase with no explicit verb and does not clarify whether the tool renders a dashboard, returns recommendations, or both. It is too vague to strongly differentiate from sibling tools like connects_feed or connects_activity.

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 statement of when to use this tool versus alternatives such as blackboard_dashboard, careers_dashboard, or the other connects_* tools. The description gives no context about the intended use case, prerequisites, or exclusions, leaving the agent to infer usage from the name and enums.

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 read-only, idempotent, non-destructive, open-world behavior. The description adds useful scope boundaries—'visible attendee directory' and no credential export—but it says nothing about pagination behavior, data freshness, or other operational traits, so it adds only modest context beyond the annotations.

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 short sentences that front-load the core purpose and then add one clarifying exclusion. Every word earns its place, and there is no redundant restatement of the tool name or schema fields.

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?

Annotations and the presence of an output schema reduce the need for the description to explain return values or safety behavior, and the core dual behavior is covered. However, it omits how `query`, `limit`, and `offset` apply to the attendee directory and gives no explicit routing cue away from `connects_events`, leaving moderate 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?

Schema description coverage is 0%, so the description should compensate by explaining parameters. It does map the `view` enum to 'details' versus 'attendees', but it offers no guidance on `query`, `limit`, `offset`, or `event_id`, leaving most parameter semantics to inference from names and schema constraints.

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 that this tool returns event details or a visible attendee directory, and it adds an explicit exclusion for registration, ticket, and QR credential export. It is distinguishable from the plural sibling connects_events, though it lacks an explicit verb like 'retrieve' or 'list'.

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

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

The description implies use when single-event details or attendee visibility are needed, and it provides a negative boundary with 'No registration, ticket, or QR credential export.' However, it does not name alternatives or explicitly say when to prefer connects_events, leaving routing mostly 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 indicate read-only, open-world, idempotent, and non-destructive behavior. The description adds significant value beyond that by explaining logical pagination over sparse upstream buckets and clarifying that scan_exhausted indicates an incomplete bounded search rather than absence of more events. This is precisely the kind of behavioral context agents need.

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 three focused sentences with no filler. The primary action is front-loaded, and each subsequent sentence provides meaningful operational detail about pagination.

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 output schema handles return values and annotations handle the safety profile, while the description covers the main hidden complexity: sparse pagination and scan_exhausted semantics. Remaining gaps are mostly parameter-level explanations, which are partially inferable from property names and enums.

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 by explaining parameters. It mentions next_offset and hints at personal scope with 'registered upcoming or past events', but limit, query, category, group_id, and offset semantics are not defined. Agents are left to infer meaning from parameter names and enum values alone.

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 clear verb+resource pair, 'Search/list events', and adds important scope detail ('registered upcoming or past events'). However, it does not explicitly distinguish itself from the singular sibling connects_event, leaving some differentiation to inference.

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

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

The description implies this is the tool for searching and listing events, and the pagination note helps agents use it across sparse result sets. There is no explicit when-to-use versus alternatives such as connects_event or when not to use it, so the guidance is present but not fully articulated.

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. The description adds meaningful context: it never posts, never changes read state, and only returns 'visible' viewer records. This complements rather than contradicts the annotations.

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 concise sentence that front-loads the action and resource, then adds exclusionary scope. No word is wasted and no schema details are redundantly repeated.

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 rich annotations and an output schema, the description is incomplete for a 5-parameter tool. It omits parameter dependencies (e.g., when post_id is required), what 'visible viewer records' means, and how group_id scopes the feed. An agent cannot reliably construct a correct call from this description alone.

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 0% schema description coverage, the description must compensate. It only loosely maps to the view enum (feed/posts/comments/photos/viewers) but does not explain limit, offset, post_id, group_id, or how post_id/group_id interact with the selected view. This leaves key parameter semantics undefined.

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 starts with 'Read' and lists specific resource types: 'feed posts/comments/photos or visible viewer records.' It also explicitly states what the tool does not do ('without posting or changing read state'), making its purpose unmistakable and distinct from write-oriented 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 implies the tool is for reading feed content and viewer records but does not provide explicit when-to-use versus when-not-to-use guidance or name alternative tools. The phrase 'without posting...' hints at a limitation but doesn't route the agent to a posting 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?

The annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, and the description is consistent with those. It adds useful context by clarifying that the tool does not support joins or survey submissions, which goes beyond the annotations and helps set expectations about the scope 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?

The description is a single, front-loaded sentence that conveys the core action and key exclusions without redundancy. Every word contributes meaningful 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?

The output schema and annotations cover returns and safety, and the description clarifies single-collection reads. However, with five parameters and zero schema descriptions, the lack of guidance on pagination, filtering via query, or how view interacts with the other parameters leaves a notable gap 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?

Schema description coverage is 0%, so the description should compensate by explaining parameters, but it only loosely hints at the view concept with 'about page or one structured collection.' It does not explain group_id, limit, query, or offset, even though the schema provides no descriptive text for them.

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 'Read' and identifies the resource: a single group's about page or one structured collection. It clearly distinguishes this from list-oriented or joining tools by emphasizing 'no joins' and 'other writes', and the singular framing differentiates it from sibling tools like connects_groups.

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

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

The description implies usage for reading a single group's content and explicitly excludes joins, survey submissions, and writes. However, it does not name any alternative sibling tools or state concrete conditions like 'use this when you need one group's data rather than a list of groups.'

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 read-only, idempotent, non-destructive behavior. The description adds valuable behavioral context beyond annotations: 'local pagination' and 'at most 1,000 matches' clarify how results are bounded and iterated. This is meaningful supplemental information for an agent deciding whether this tool can satisfy a request.

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 tight sentence that front-loads the core purpose and immediately states the key limitation. There is no filler, repetition, or unnecessary detail.

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 gives a good high-level purpose and an important pagination constraint, and an output schema exists to document return values. However, with five optional parameters and no schema-level descriptions, the tool is not fully specified: an agent cannot confidently know how query/category filtering works or how they interact with 'mine'. This leaves a noticeable gap.

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 explaining the five parameters. It only hints at 'mine' through 'your memberships' and vaguely at pagination through 'local pagination', but it does not explain the semantics of 'query', 'category', 'limit', or 'offset'. For a 0%-coverage schema, this is insufficient.

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 ('Find') and a clear resource ('groups/clubs or your memberships'). It distinguishes the list/search purpose from the singular sibling 'connects_group', though it does not explicitly name that alternative. The pagination note adds further clarity about what this tool returns.

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

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

The description implies this tool is for searching or listing groups and memberships, and the 'at most 1,000 matches' note sets an expectation about scale. However, it provides no explicit guidance on when to prefer this tool over siblings like 'connects_group', 'connects_events', or other list tools, and it does not state any exclusions.

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 openWorldHint, so the description adds value by reiterating the 'visible' scope and explicitly warning that an empty result is not proof of absence. This behavioral nuance goes beyond the structured annotations and helps the agent interpret results correctly.

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 carry meaningful guidance: the resource and action in the first, and an important interpretational caveat in the second. There is no filler, redundancy, or unnecessary detail.

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 six optional parameters, an output schema, and an annotation set that covers safety and openness. The description clarifies the domain ('visible IE directory') and the open-world caveat, but does not cover how to use filters or pagination, nor does it mention any authentication requirements suggested by sibling tools like ie_auth_status. For a search tool with many optional parameters, the description is minimally adequate but not 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 description coverage is 0%, and the description provides no parameter-level guidance. While names like 'city', 'company', 'graduation_year', and 'query' are self-explanatory to some degree, the description does not explain how filters combine, what 'query' matches, or how pagination works. With zero coverage in the schema and no compensation in the description, this is a significant gap.

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 ('Search'), a resource ('the visible IE directory'), and clearly sets it apart from the singular sibling connects_person. It does not explicitly name the sibling, but the plural 'people' and the verb 'search' signal a directory lookup rather than a single-record fetch.

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 gives context about searching the visible IE directory and cautions against concluding a person is absent from an empty list. It does not explicitly state when to use this tool versus alternatives, nor does it mention exclusions, prerequisites, or filter combination rules. The privacy caution is useful but does not fully replace alternative guidance.

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 signal read-only and non-destructive behavior, and the description reinforces this with 'Never changes connections.' It adds behavioral context about matching being by returned ID/UID or exact full name, which is not visible in the schema.

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 compact sentence conveys the action, key matching rule, optional view, and read-only guarantee without redundancy. 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?

With an output schema present and annotations covering safety, the description is sufficient for the core lookup and connections views. The only notable gap is the lack of any explanation of the mutual and suggestions view variants, though the enum values make them discoverable.

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 clarifies the person parameter's accepted formats and hints at the view parameter via 'optionally visible connections,' but it does not explain mutual/suggestions views or the limit/offset parameters, leaving part of the burden to schema constraints.

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 ('Read'), identifies the resource ('profile'), and states the exact lookup keys ('returned ID/UID or exact full name'). It also notes the optional connections view, which distinguishes it from broader list tools like connects_people.

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 clearly indicates when to use the tool: when the caller has a returned ID/UID or an exact full name. It does not explicitly name alternatives or exclusion conditions, but the lookup-key phrasing provides enough context for an agent to choose it over listing-oriented siblings.

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 readOnlyHint, idempotentHint, and non-destructive behavior; the description adds the concrete scope of what is not supported (purchases, applications, payments) but no further operational traits such as pagination behavior or open-world data volatility. With annotations carrying the safety profile, this is adequate but not enriched.

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 core action, and every phrase ('Read...', 'No purchases...') adds relevant scope. There is no wasted prose.

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 output schema and annotations cover return values and safety, and the description covers the high-level scope. However, missing parameter semantics and lack of comparison to sibling tools leave an agent to infer important usage details such as the filters view and fair_id 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?

Schema description coverage is 0%, so the description must compensate for parameter meaning. It only hints at the collection/fair domain by listing those nouns, while view, limit, query, offset, and fair_id are left entirely to their schema titles and enums. That is insufficient for six parameters.

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

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

The description opens with the verb 'Read' and enumerates exact resource categories (jobs, mentorships, marketplace, stores, fairs), so an agent can tell what the tool operates on. It stops short of naming sibling tools, so it doesn't fully differentiate from overlapping tools like careers_jobs or connects_dashboard.

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 read-only framing and the explicit 'No purchases, applications or payments' exclusion give clear context for when the tool is appropriate. However, it never names an alternative or states when another sibling should be preferred, so the differentiation is only implied.

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 and destructiveHint=false, so the description's 'Cannot book or cancel rooms' adds a meaningful behavioral boundary beyond the annotations. It makes clear this is a read-only informational tool and not a mutation endpoint. No annotation contradiction exists.

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 concise sentence with no filler. It front-loads the core capabilities and immediately adds a clarifying limitation. Every word contributes 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?

With 8 parameters, zero parameter descriptions, and no explanation of how filters combine or what values capacity/duration/time_of_day accept, the description is not sufficient for reliable invocation. The output schema may help with return values, but input construction remains underspecified. The tool definition is too thin relative to its complexity.

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 0% description coverage for its 8 parameters, so the tool description must compensate, but it only hints at the 'view' parameter by listing availability, filters, details, and reservations. The parameters day, capacity, duration, time_of_day, room_id, limit, and offset remain unexplained. This is a significant gap for an agent trying to invoke the tool with correct filter semantics.

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 identifies the resource (rooms) and the scope: availability, filters, details, and existing reservations. It also differentiates itself from booking/cancellation operations and from sibling tools like connects_events or connects_schedule by focusing on room-specific data. It lacks an explicit verb like 'query' or 'list', but the meaning 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 implies this tool should be used for room availability, details, filters, or reservations, and explicitly states it cannot book or cancel rooms. However, it does not name alternative tools or provide explicit when-to-use/when-not-to-use guidance beyond the booking/cancellation exclusion. The usage context is mostly 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 cover read-only, idempotent, and non-destructive behavior. The description adds real value beyond that: per-page date filtering semantics and the non-obvious instruction to continue next_offset even when a filtered page is empty. This prevents an agent from terminating pagination prematurely.

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 short sentences, each earning its place: resource identity, then the two non-obvious behavioral rules. No fluff, no repetition of schema defaults, and the most decision-relevant facts are front-loaded.

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 an output schema and safety annotations, the critical pagination and date-window behavior is well covered. However, one of five parameters (calendar) is entirely undocumented in both schema and description, and there is no statement about which calendar is used by default. An agent would have to guess or probe.

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 carry the parameter burden. It does clarify start/end (ISO format, 31-day window) and offset (continue next_offset), but calendar is never mentioned, and limit's semantics are left entirely to the schema's numeric bounds. Partial compensation at best.

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?

'Student schedule' clearly names the resource returned, distinguishing it at a glance from sibling tools like connects_events, connects_feed, or blackboard_calendar. It lacks an explicit verb ('get', 'list'), but the intent is unambiguous and the resource identity is specific.

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 gives concrete operational direction: how to handle pagination when filtered pages come back empty, that dates must be ISO, and that the filter window is capped at 31 days. It does not explicitly say when to prefer this over sibling tools, but the constraints given are genuinely actionable.

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, openWorld, idempotent, and non-destructive behavior. The description adds valuable behavioral context beyond the annotations: it states the check is live, requires no browser, and provides the important caveat that outages should not be misinterpreted as logged-out states. This is exactly the kind of interpretive guidance an agent needs.

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 concise sentences with the primary action front-loaded. The first sentence states what the tool does; the second provides a necessary interpretive caveat. No filler or redundant information is present.

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 read-only status tool with one enum parameter, rich annotations, and an output schema, the description covers the essential semantic point and adds the critical outage caveat. However, it omits any mention of the 'service' parameter and does not clarify how it relates to sibling auth tools, leaving a moderate gap.

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 by explaining the parameter. It does not mention 'service' at all or explain that it selects the platform (connects or blackboard) to check. While the enum values are self-explanatory, the description fails to close the documentation gap for this required parameter.

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 and resource: 'Check live sign-in without opening a browser.' This clearly communicates the tool's function and distinguishes it from browser-based login flows. The caveat 'Outages are not logged-out states' further clarifies the intended interpretation of the result.

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 'without opening a browser' implies a contrast with browser-based tools, but no alternatives are named and there is no explicit when-to-use or when-not-to-use guidance. The description does not differentiate this from similar siblings like ie_login_status, leaving the agent to infer the appropriate 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 establish read-only, idempotent, and non-destructive behavior. The description adds meaningful context by limiting results to profile names/IDs and explicitly excluding cookie values, which is a key privacy-related behavioral guarantee. It does not detail output ordering or empty-result behavior, but the output schema covers the return 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 front-loads the action and resource, then appends the important limitation. There is no filler or repetition of schema or annotation 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?

For a zero-parameter, read-only list tool with strong annotations and an output schema, the description gives the essential purpose and a notable exclusion ('no cookie values'). Nothing critical is missing 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?

This tool has zero parameters, so the input schema is already complete and there is no parameter behavior to explain. The description's statement about listing names/IDs without cookies clarifies the result scope instead, matching the baseline for zero-parameter 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?

Uses a specific verb 'List' with a clear resource ('normal Chrome/Brave/Edge/Chromium profile names and IDs'), and the appended 'no cookie values' clarifies the intended scope. This differentiates it from sibling ie_* auth/login tools, which concern authentication state rather than profile enumeration.

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 states what the tool is for, so an agent can select it when profile enumeration is needed, and the 'no cookie values' note sets a boundary. It does not explicitly name alternatives or say when to prefer a sibling tool, so it falls just short of full guidance.

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 provide only generic hints (all false), so the description carries the burden of behavioral disclosure. It reveals side effects: 'Clears only this process's cached session, never logs the browser out,' and explains source-specific behavior. This goes beyond the structured annotations and gives the agent important safety-relevant 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?

Three sentences with no filler, each contributing distinct value: purpose, usage timing, side effects, and source edge cases. The most important action is front-loaded. This is appropriately concise for a configuration 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?

With an output schema present, return values are not the description's job. The description covers when to use it, side effects, and source-specific behavior, but omits any explanation of the required `service` parameter, which is critical for correct invocation. It also does not say what 'persist' implies for future sessions beyond clearing cache. The overall picture is functional but 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%, so the description must compensate. It indirectly covers browser, profile, and source ('browser selection', 'profile/source', 'Isolated'/'managed'), but it never explains the required `service` parameter (connects/blackboard). This is a meaningful gap for the one required field, though the other parameters receive partial context.

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

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

The description states a specific action ('Persist non-secret browser selection') and indicates it configures auth after a user chooses a profile/source. This distinguishes it from siblings like ie_login_start or ie_auth_status, though 'non-secret browser selection' is somewhat roundabout. Overall the core purpose is clear.

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 says 'Use after the user chooses a profile/source,' giving a clear trigger condition. It also differentiates source behavior ('Isolated needs no normal-browser extraction; managed uses OpenClaw port 18800'), which helps route the agent. It does not explicitly name alternatives or exclusions, but the context is sufficient.

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 adds "No network," which is valuable behavioral context beyond the annotations: the tool performs no network calls and is safe/fast to invoke. Combined with the annotations indicating read-only, idempotent behavior, the agent has a clear safety profile.

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 most important directive ('Start here') and then lists the contained content in a scannable series. Every word contributes 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, read-only, idempotent guide tool with an output schema, the description covers what the tool is for, what it contains, and its network behavior. Nothing critical 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 has zero parameters, so there is no parameter semantics burden on the description. A baseline of 4 is appropriate because nothing about parameters needs explaining.

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 identifies this as a starting point containing setup instructions, browser sign-in steps, usage examples, and scope. It distinguishes itself from the many data-access sibling tools by framing itself as an onboarding/guide tool rather than a data operation.

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?

"Start here" explicitly tells an agent when to invoke this tool: before engaging with other tools. It provides clear context for first use, though it does not explicitly name alternatives 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?

Beyond the annotations, the description discloses important runtime behavior: it returns immediately, the login session depends on human password/MFA entry in the browser, and it rejects credentials and arbitrary URLs. This meaningfully adds context about side effects and limitations that annotations alone do not convey.

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 operation, then follows with behaviorally important caveats. Every sentence earns its place and there is no 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?

For a tool that only starts a human-driven SSO flow, the description covers its trigger, immediate return behavior, human-only authentication, and non-acceptance of credentials/URLs. Combined with the schema enum and output schema, an agent has enough context to invoke 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 single service parameter is fully defined by the schema's enum (connects or blackboard), but the description itself adds no explanation of how the parameter influences the login target. With 0% schema description coverage, the description doesn't compensate, though the enum mitigates the gap.

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 (open or reuse the selected browser), a target (IE/Microsoft SSO), and a condition (only when the user wants to sign in). It also differentiates itself by explicitly saying it does not accept credentials or arbitrary URLs, which distinguishes it from auth configuration or URL-navigation 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 gives a clear condition: use only when the user wants to sign in, and it warns that passwords/MFA are human-only and credentials cannot be supplied. However, it does not explicitly name alternative sibling tools or say when to prefer them instead.

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 convey read-only, idempotent, non-destructive behavior. The description adds valuable behavioral context beyond that, namely that no browser is opened and that the tool only reflects the active sign-in job's status. It does not fully explain what 'expiry' means, but enough is disclosed.

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, no filler, with the core action first and the routing guidance second. Every phrase 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?

For a simple read-only status probe with annotations, an output schema, and a single enum parameter, the description is largely sufficient. It could be slightly more explicit about what 'expiry' refers to and how this relates to starting a login, but the core selection and invocation context is present.

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 does not mention the required 'service' parameter at all. The schema's enum provides valid values (connects/blackboard), but the description adds no guidance about which service to pass or why it matters.

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 and resource: 'Check the active sign-in job.' It also adds a key distinguishing trait, 'does not open a browser,' and names a sibling tool for the later auth state, making the purpose unambiguous.

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

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

It gives explicit routing guidance: after expiry, use ie_auth_status to detect a sign-in completed later. This tells the agent both when this tool is appropriate and when to switch to a specific alternative.

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