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?

Even though annotations already indicate read-only, open-world, idempotent, and non-destructive behavior, the description adds valuable context: the 31-day cap, the distinction between legitimate empty data and access_denied, local filtering semantics, and the absence of booking/registration side effects. This meaningfully 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?

Four short, dense sentences with no filler. The core purpose is front-loaded, and every sentence contributes either a scope constraint, an error-interpretation caveat, filtering behavior, or a side-effect disclaimer.

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 rich annotations and output schema reduce the burden on the description. The description covers the most important behavioral gotchas and scope limits for a read-only calendar tool. It is slightly incomplete on pagination parameters and single-event retrieval via event_id, but it is sufficiently complete for an agent to call the tool safely and correctly in most cases.

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 carries the burden of explaining parameters. It does help with the date-window concept, view variants, and adviser/type refinements, but it leaves event_id, limit, offset, and exact since/until format undocumented. This is partial compensation, not full coverage.

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 ('career calendar or advising availability') and the scope of data (up to 31 days, types/offices, role-dependent events). It avoids being a tautology and is distinct from sibling tools like careers_jobs or blackboard_calendar, though it lacks an explicit action verb such as '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 provides useful operational guidance: empty results can be valid, access_denied is not the same as no events, adviser/type refinements apply locally to the full date-window response, and the tool does not handle bookings. However, it never explicitly says when to use this tool versus sibling alternatives such as careers_dashboard or blackboard_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?

The description goes well beyond the annotations by detailing side effects: default is preview/no-write, advance_baseline commits private local state only after a complete scan, first scan marks all matches added, and truncated output is not the full change list. It also warns to persist returned changes before committing. No contradiction with readOnlyHint=false, idempotentHint=false, or destructiveHint=false.

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?

Every sentence carries operational weight: the core function, default safety, baseline flags, first-scan behavior, notification guarantee, and persistence caveat. It is dense but well-front-loaded and not bloated.

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 stateful baseline behavior and potential truncation, the description covers the critical decision points: preview vs. commit, when to reset, first-scan behavior, no notifications, and reliability guidance for downstream consumers. The output schema exists, so return-value documentation is not the description's job.

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

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

Schema coverage is 0%, so the description must compensate. It explains advance_baseline and reset_baseline well, and the truncation warning indirectly relates to max_items. However, the required 'name' parameter is not semantically explained at all, and max_items is never explicitly linked to output size, leaving an agent to guess what value to provide.

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

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

The description opens with a specific verb and resource: 'One-shot complete search diff: new, changed and no-longer-matching jobs.' This clearly distinguishes the tool from siblings like careers_searches and careers_jobs by framing it as a diff operation rather than a plain listing or save action.

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

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

It explains exactly when to use the default preview vs. advance_baseline=true, and when reset_baseline is appropriate ('explicitly changed query/account'). It also states what the tool never does ('Never schedules or sends notifications'), helping an agent choose it only for diffing, not for notification workflows.

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 a safe read-only, idempotent, non-destructive profile. The description adds a meaningful behavioral caveat: larger nested data may be truncated, which is not visible from the annotations or the empty input schema. This is useful disclosure beyond the structured metadata.

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

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

The description is two sentences: the first front-loads the dashboard contents, and the second adds the truncation caveat and routing guidance. No words are wasted.

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

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

With zero parameters, an output schema present, and annotations covering safety, the description provides the remaining essential context: the dashboard contents and the truncation behavior. An agent has enough information to invoke it correctly and know when to switch to a dedicated tool.

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

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

The input schema has no parameters, so there is no parameter semantic burden for the description to carry. The 0-parameter schema is fully documented, and the baseline for this case is 4.

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 a career-portal dashboard covering announcements, calendar, recommended and recent opportunities. It lacks an explicit verb such as 'get' or 'list,' but the title and noun-phrase summary make the purpose clear. It only broadly distinguishes itself from 'dedicated paginated tools' rather than naming specific siblings, so it falls just short of a 5.

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 a top-level overview of career portal content. It also states a clear when-not-to-use condition: if larger nested data is needed, use dedicated paginated tools. It does not name the specific sibling tools, but the sibling list makes them discoverable.

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 operation as non-read-only, non-idempotent, non-destructive, and open-world. The description goes beyond this by revealing that it generates a filename, is cookie-free and allowlisted, enforces a 100 MiB/40-second budget, and rejects arbitrary paths/uploads/external fetches. This materially informs the agent about side effects and constraints that annotations do not capture; 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?

Three short sentences, with the primary action and destination front-loaded and constraints stated compactly. Each clause adds distinct information—privacy, filename generation, transport mode, budget, and exclusions—so there is no redundancy or 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?

The definition covers the tool's restrictions, budget, and security model, and the output schema exists for return-value details. The main gaps are minor: it doesn't state authentication prerequisites or how 'permitted' is determined, though sibling auth tools make that inferable. Overall it gives an agent enough to invoke correctly for a simple two-parameter download.

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

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

The schema provides 0% description coverage for kind and item_id, and the description does not explain either parameter. It only loosely implies that item_id references a 'permitted existing file,' and the kind enum values are self-descriptive but the description never maps them. With weak schema coverage and no compensatory detail, parameter understanding is largely left to inference.

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

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

The description names a specific action ('download'), a resource ('permitted existing file'), and a destination ('generated filename on the MCP host'), so the agent knows what the tool accomplishes. It avoids tautology and conveys a distinct download-with-restrictions operation. However, it does not explicitly differentiate from sibling blackboard_download, so it stops short of full sibling-level clarity.

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

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

The description provides clear context: it is a 'cookie-free allowlisted file transport' with a '100 MiB/40-second budget' and explicitly lists exclusions ('No arbitrary paths, uploads or external URL fetches'). This implies the intended use case—downloading permitted file objects—but does not name any alternative tools or when-not conditions, so it is 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 declare read-only, idempotent, open-world, and non-destructive. The description adds that access is constrained by IE permissions and specifically disclaims side effects on messaging and target-employer lists, which is useful context beyond the raw flags. No 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?

One front-loaded sentence states the core function and then supplies a safety exclusion. Every phrase earns its place; 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 read-only parameterized lookup with output schema and rich annotations, the description is mostly sufficient: it clarifies the views and safety profile. It could be more complete by pointing to sibling tools for list-level job/employer browsing, but that gap is not fatal given the schema.

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 compensates only partially: it maps the view enum values to 'details,' 'open opportunities,' and 'contacts.' It does not explain employer_id, limit, or offset semantics, although their names and schema constraints are reasonably self-evident.

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 (employer) and enumerates the three possible data views (details, jobs, contacts), and the closing safety clause distinguishes it from messaging/list-mutation tools. It lacks an explicit verb such as 'gets' or 'retrieves,' so the action is implied rather than stated.

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 signals when to use it—when employer details, open opportunities, or IE-permitted contacts are needed—and explicitly states it never sends messages or changes target-employer lists, providing a clear 'when not' boundary. It does not name sibling tools such as careers_employers or careers_jobs as alternatives, so routing among siblings is left implicit.

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, open-world, idempotent, and non-destructive behavior, so the description adds only modest value. 'Live filter catalog' hints that results reflect current data, and 'optional name search' clarifies how the query parameter is interpreted, but there is no deeper disclosure about pagination or data freshness.

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

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

The description is a single focused sentence with no filler words. It front-loads the core action and then briefly names both parameter mechanisms, earning every word it uses.

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 output schema exists and annotations are strong, the description is minimally sufficient for a default call with no parameters. However, an agent is left to infer which filter fields are valid, how to combine query with filters, and whether pagination behavior matters, so the description does not fully support complex intended uses.

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 parameters. It covers two of the four parameters conceptually: 'name search' maps to query, and 'live filter catalog' suggests filters. However, limit and offset are not mentioned, and the description does not explain how to construct valid filter objects beyond what the nested schema definition provides.

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 resource (employers) and a clear mechanism (live filter catalog and optional name search). It is distinguishable from the singular careers_employer tool, though it does not explicitly say 'list employers' or 'search employers', relying on 'research' as a somewhat broad verb.

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 general context for use ('Research employers') but provides no guidance on when to prefer this over sibling tools such as careers_employer, careers_jobs, or careers_filters. There are no exclusions, alternative recommendations, or conditions that would help an agent route to the correct 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?

Beyond the annotations (readOnly, openWorld, idempotent, non-destructive), the description adds a concrete behavioral statement that the returned filter options are not hardcoded but live, and that query requires a minimum length for autocomplete. This gives the agent expectations about dynamic results and input constraints. No contradictions 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 three sentences, front-loads the core purpose, then provides usage guidance and a key constraint. Every sentence adds relevant information without fluff or repetition. It is concise and easy to parse.

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, so return values are covered. However, with five optional parameters and no schema descriptions, the description leaves gaps: the role of the `entity` parameter is completely absent, and the exact meaning of `field` is only implied. The 'start here' workflow hint is useful but the description doesn't fully specify how to use the tool alongside search tools. It is 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?

The schema has zero descriptions for its five parameters, so the description must compensate. It adds some meaning for the `query` parameter (2+ characters for autocomplete, exact labels/IDs preferred) and implies the `field` parameter selects the filter for which accepted values are returned. However, the `entity`, `limit`, and `offset` parameters are not explained, and even the relationship between `field` and `entity` is not stated. Overall, it provides partial but not sufficient parameter coverage.

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 tool as a read-only discovery mechanism for career filters and accepted field values, using the specific verb 'Discover' and the resource 'live filters / accepted values for field.' It distinguishes itself from sibling search tools by positioning itself as a prerequisite ('Start here before career searches') and by mentioning autocomplete capabilities. However, the 'or' phrasing slightly muddies whether it returns all filters or values for a single field.

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 instructs the agent to use this tool before performing career searches, giving it a clear temporal placement in a workflow. It also provides a rule for autocomplete behavior ('needs query (2+ characters)') and recommends exact labels/IDs to avoid ambiguity. It doesn't explicitly name sibling alternatives, but the 'start here' directive provides sufficient guidance for selecting 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?

Annotations already cover read-only, idempotent, and non-destructive behavior. The description adds useful behavioral context by stating it never starts applications or follows external sites, which matters for an agent deciding whether this tool can trigger side effects. It does not contradict any annotation.

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: the first states the tool's content, the second provides actionable pagination instructions, and the third sets a critical boundary. The most important information 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?

The tool has a moderately complex input schema, an output schema, and rich annotations. The description covers pagination and side-effect limitations sufficiently. It could name the sibling careers_jobs tool to make selection easier, but this is not critical for invoking the tool correctly.

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

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

Schema description coverage is 0%, so the description carries the burden. It explains the meaning of section=description and text_offset chunking, and the enumerated output fields clarify what job_id retrieves. However, it does not explicitly elaborate on the other section enum values, leaving some room for inference.

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 clearly identifies the resource (a single job) and the information it returns: description, requirements, deadline, application methods, and source link. It distinguishes itself from sibling careers_jobs by using the singular job focus and by describing a detail-viewing purpose rather than a list/search purpose.

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 guidance for handling long descriptions: use section=description and follow next_offset as text_offset in 4,000-character chunks. It also explicitly states what the tool never does, preventing misuse, though it does not name sibling alternatives or exclusion conditions.

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 readOnly, idempotent, and non-destructive behavior, and the description reinforces this with 'No applications or favorites are changed.' It adds non-obvious behavioral details: default status filtering, Europe/Madrid timezone handling, live filter behavior, and the requirement to reuse the same query when following next_offset.

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

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

The description is compact and front-loaded with the core purpose. Every sentence adds operational value: filter semantics, default statuses, pagination, timezone, and safety. There is no repetition of schema details or annotation content.

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

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

For a search tool with an output schema, the description covers the essential operational context: prerequisite tool, filter composition rules, pagination, status defaults, timezone, and non-destructive behavior. Nothing critical an agent needs to call it correctly is missing.

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

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

With schema description coverage at 0%, the description compensates by explaining the complex filter semantics: OR within a field, AND across fields, ranges via from/to, and exclusions via exclude=true. It also explains all_statuses and next_offset usage. It does not explicitly cover query, sort, source, or limit, but those are self-evident from their names and schema enums/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 opens with 'Search opportunities with live typed server-side filters', naming a specific verb and resource. It clearly differentiates from sibling tools like careers_job or careers_employers by positioning itself as the search/list 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?

It explicitly says 'Use careers_filters first', providing an ordering constraint and prerequisite. It also tells the agent when to use all_statuses for application history and how to paginate with next_offset, giving concrete guidance beyond mere capability.

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 and idempotentHint, so the description adds value by revealing the item_id dependency for detail views and the boundary that downloads are handled elsewhere. It also reinforces the read-only nature, consistent with annotations. It does not need to re-state safety traits the annotations already provide.

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

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

Three short, purposeful sentences: purpose, detail-view requirement, and routing/exclusions. Information is front-loaded, and every sentence earns its place without redundancy.

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

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

The tool has an output schema, so return values don't need description. The description covers how to list, how to get details, and where downloads belong. Given the read-only annotations and simple parameter set, nothing important is missing for correct invocation.

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

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

With 0% schema description coverage, the description compensates for the most important parameter relationships: it maps view to document/résumé-book lists and details, and explains that item_id must come from a preceding list call. It does not explain limit/offset, but those are conventional pagination parameters. The enum values are self-explanatory once the description clarifies singular vs. plural.

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

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

The description opens with a specific verb and resource: 'Read existing application documents or résumé books.' This clearly distinguishes careers_materials from sibling tools like careers_jobs and careers_download. It also specifies that detail views require an item_id from a list, making the tool's scope 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 explicitly routes downloads to careers_download ('Downloads use careers_download') and states what the tool does not do ('no uploads or book registrations'). It also explains the list-then-detail workflow: 'Detail views require an item_id returned by their list.' This gives clear when-to-use and when-not-to-use 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 mark the tool readOnly, idempotent, and non-destructive, and the description adds meaningful context beyond those annotations by explicitly ruling out profile edits and new interview reports. It also clarifies the scope of interview data, distinguishing personal recorded history from a shared question bank. No contradiction exists with 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 three short sentences with no filler. The primary action and target resource are front-loaded, and the follow-up sentences each add a distinct limitation or clarification that earns their 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?

This is a simple read-only tool with one optional enum parameter, no required arguments, strong annotations, and an output schema. The description fully covers what the tool can access and what it cannot do, which is sufficient for an agent to select and 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 schema provides a single section parameter with an enum, but the description adds meaning by explaining that the values correspond to the user's own profile, education, and recorded interview history. It does not explicitly describe 'past-education', but the enum labels are largely self-explanatory and the description compensates for the 0% schema description coverage.

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 names the exact resources: your own career profile, education, and recorded interview history. It further distinguishes the tool by clarifying that interviews are not a shared question bank, which separates it from a generic interview database 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 clearly indicates when to use the tool: when the agent needs to read the user's own career profile, education, or recorded interview history. It also provides when-not guidance by stating that profile edits and new interview reports are not supported, though it does not explicitly name alternative 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds the meaningful distinction that these are recommendations rather than filtered search results, but it does not describe behavior like pagination or stability. This is acceptable given the annotations carry the behavioral burden.

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 core action and adds a crucial scoping distinction. Every word earns its place, with 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?

For a simple read-only tool with one optional parameter, the description plus annotations and output schema provide enough context for correct invocation. It could have provided slightly more detail about what the recommendations represent, but the openWorldHint and the search-versus-recommendations distinction cover the essentials.

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

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

The only parameter, limit, is fully described in the schema with title, default, minimum, and maximum, so an agent already knows how to use it. The description does not add parameter-specific meaning, but with schema coverage essentially complete for the single optional parameter, the baseline of 3 is appropriate.

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

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

The description clearly states it reads the career portal's recommendations, using the specific verb 'Read' and the resource 'recommendations'. It also distinguishes this from filtered search results, which helps an agent understand the unique purpose among siblings like careers_jobs and careers_searches.

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 useful context by explicitly stating this is not the same as filtered search results, telling the agent when not to use it. It does not name an alternative tool by name, but the contrast with search results is a clear usage signal given the sibling list includes careers_searches and careers_jobs.

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 meaningful behavior beyond the readOnly/idempotent annotations: external links are never fetched, tree results are capped at 60 folders, and detail requires an item_id. These are non-obvious constraints that materially affect how an agent invokes the tool and interprets results. 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?

Three short sentences deliver the essential scope, safety behavior, parameter requirement, sibling routing, and a hard limit. Every sentence earns its place and the primary purpose 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?

With the output schema present and annotations covering safety, the description covers the important exceptions: external links, tree cap, detail preconditioning, and download routing. It is nearly complete, though it could have briefly noted how to narrow tree results using query or folder_id.

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%, but the schema itself uses clear property names, titles, enums, and defaults. The description adds meaning for item_id (detail requirement) and folder_id/tree cap, but it does not explain the query/offset/limit pagination semantics or how exactly to narrow large tree results beyond 'must be narrowed.' This is adequate but leaves some param behavior to inference.

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 specific actions (browse/search/traverse) and a clear resource (career resources / folder tree), and it distinguishes itself from the download sibling by routing file downloads to careers_download. It is more specific than a tautology, though it does not explicitly differentiate from other career-related browse tools like careers_materials.

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 useful context: detail views require item_id, file downloads belong in careers_download, and tree results are capped at 60 folders requiring narrowing. It does not explicitly list when to prefer this tool over sibling resource tools, but the download routing and tree limitation provide practical selection 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?

The description goes well beyond the annotations by explaining the validate-then-save flow, local-only scope, absence of portal alerts or scheduled actions, and the precise semantics of replace=true overwriting only the named local definition. This gives the agent a clear side-effect model.

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, front-loaded with the core action, followed by exclusions and replace behavior. Every sentence adds distinct value 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 mutating tool with an output schema, the description covers validation, local-only persistence, side-effect exclusions, and replace semantics well. It is slightly incomplete on parameter meanings and on when to choose this over sibling search-related tools, but the output schema and parameter names fill some 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 needed to compensate, but it only explains replace=true. The other seven parameters, including query, filters, sort, source, ascending, and all_statuses, are left to inference from their names and enum values.

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

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

The description states a specific action ('save') and a specific resource ('credential-free LOCAL search preset'), and distinguishes it from portal alerts and scheduled sends. It also clarifies the CLI sharing, making the tool's role unmistakable even among many sibling tools.

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

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

The description clearly says this should run 'only when requested,' which gives an explicit usage boundary. It also states what the tool does NOT do, but it does not name an alternative tool or describe when to prefer a sibling like careers_searches or careers_check_search.

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 useful behavioral detail beyond those annotations: local presets are shared with iecareers, show/run modes require a name, and pagination via next_offset is needed for complete lists. It 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?

The description is three tight sentences. It front-loads the core purpose, then provides the two most important operational constraints (name requirement and pagination) without wasted words. Every sentence contributes information an agent needs.

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 four parameters and multiple view modes, the description covers the main operational contract: safe read-only behavior, view modes, name requirements, and pagination. Since an output schema exists, return-value documentation is not necessary. Minor gaps like the precise meaning of 'limit' and 'offset' keep it from being 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?

The input schema has 0% description coverage, so the description must compensate. It does explain the crucial behavior around 'name' (required for show/run) and maps view modes to actions ('run', 'portal', 'show'). However, it leaves 'limit' and 'offset' semantically under-explained, only hinting at pagination through 'next_offset'. This is meaningful but incomplete compensation.

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 tool's resource ('career search presets') and enumerates the supported operations: read presets, run a preset, or inspect portal saved searches. It uses a specific verb-resource combination and the named behaviors distinguish it from sibling tools like careers_save_search or careers_check_search.

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 practical guidance: 'No baseline changes' signals it is safe to explore, 'Show/run require name' tells the agent when the name parameter is necessary, and 'Follow next_offset for complete lists' provides pagination behavior. It does not explicitly name alternative tools or exclusion conditions, but the context is clear enough for an agent to decide when to use 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.