MSPortfolio — MCP-Native Engineering Portfolio

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

Annotations already indicate readOnlyHint=true, so the description need not restate safety. It adds value by disclosing the output structure ('per-skill match with evidence and coverage'), though 'evidence' remains vague. 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 concise sentences, front-loaded with purpose and output. 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?

For a simple one-parameter, read-only tool with no output schema, the description adequately covers purpose, behavior, and return shape. The term 'evidence' is a minor gap, but the tool is otherwise fully contextualized.

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 fully describes 'required_skills' as 'Skills the job requires', giving 100% coverage. The description reinforces this but adds little beyond connecting it to the comparison. Baseline 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 uses the specific verb 'compare' and clearly identifies the resource ('owner's stack' against 'job's required skills'). It also states what is returned (per-skill match with evidence and coverage), which distinguishes it from sibling retrieval/verification 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 implies the context for use: when you need to assess a candidate's skills against job requirements. However, it does not explicitly mention alternatives or exclusions, so it stops short of a 5.

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 readOnlyHint=true and openWorldHint=false; the description repeats 'Read-only, closed world' without adding new behavioral traits like auth or rate limits. It does add content structure (why/when/how fixed/lesson), which is helpful given no output schema, but the behavioral disclosure is minimal beyond 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 concise and front-loaded, using a single clear sentence plus a final clarification. Every word adds value, with no redundancy or fluff.

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

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

For a zero-parameter, read-only tool with no output schema, the description sufficiently covers what is returned and the structure of the items. Annotations handle safety semantics, making this complete for an AI 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?

The tool has zero parameters, so no semantic explanation is needed. Baseline of 4 is appropriate as the description clarifies the closed-world nature, which aligns with the empty 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 clearly states the tool returns 'the owner's antipattern museum' with explicit content details (why they were bad, how fixed, lesson). This distinguishes it from siblings like get_engineering_principles and get_known_issues by focusing on mistakes/lessons.

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 implied usage context (use when you need antipatterns), but it does not explicitly state when to use it over alternatives or any exclusions. There is no mention of alternatives or conditions, which would make it clearer.

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 openWorldHint=true, so the description need not restate these. It adds useful context by specifying the data source (Dev.to) and returned fields, but does not clarify behavior such as recency limits, pagination, or response structure, which is acceptable given the simple nature and annotation coverage.

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, direct sentence that conveys the core function and expected output with no filler. It is well suited for quick parsing by an AI agent.

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 tool has no parameters and no output schema, the description covers the essential information: what is fetched (articles), the source (Dev.to), and the key fields returned. It could note the meaning of 'recent' or whether results are sorted, but for the scope, it is sufficiently complete.

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

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

The input schema has zero parameters, so there is no parameter behavior to document. The description appropriately focuses on the output attributes (reading time, tags, links) rather than inputs, matching the baseline for tools with no parameters.

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

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

The description clearly identifies the action ('Get') and the resource ('recent Dev.to articles'), and specifies returned attributes (reading time, tags, links). It is distinct from sibling tools like verify_article or get_profile, so there is no ambiguity about its 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 no guidance on when to use this tool versus alternatives. It does not mention exclusions, prerequisites, or typical use cases. Sibling tools like verify_article or get_timeline are not referenced, leaving the agent to infer its role.

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 openWorldHint, and the description adds useful context: the data is an 'hourly snapshot', implying it may not be real-time. It also clarifies scope to public repos of the owner. 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?

Two concise sentences: the first states what the tool does and its scope, the second provides concrete usage examples. No filler, front-loaded with the action.

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 no parameters, no output schema, and good annotations, the description is complete: it explains what data is returned, the scope (public repos), the freshness (hourly snapshot), and example questions it answers. No 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?

The input schema has no parameters, so the description doesn't need to explain parameter semantics. It adds contextual meaning by describing the data output (recent commit history, scope, snapshot freshness), which is sufficient for a zero-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?

Description clearly states the action ('Get recent commit history'), the resource ('the owner's public repos'), and includes a scope qualifier ('hourly snapshot'). It also distinguishes itself from siblings by focusing on commit history rather than profiles, projects, or articles.

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

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

Explicitly provides example use cases ('what has he been building lately' or 'show the hardest bugs he has fixed'), giving agents clear when-to-use guidance. Though it doesn't mention alternatives, the examples make the tool's purpose and appropriate context unambiguous.

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 openWorldHint=false, and the description repeats 'Read-only, closed world' without adding new behavioral constraints. It adds qualitative content details (pattern tags) but no further side-effect or scope information beyond what annotations 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?

Two sentences, front-loaded with the core purpose, content summary, and usage examples. No filler or redundant wording; every sentence earns its place.

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

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

For a no-parameter, read-only tool, the description is fully complete: it defines the resource, its contents, when to use it, and explicitly notes the read-only and closed-world nature. No output schema exists, but the description sufficiently characterizes the expected data.

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?

There are zero parameters and the schema is an empty object, so schema description coverage is 100%. The description adds meaning about the resource content, but parameter-specific semantics are not applicable. A baseline of 4 is appropriate given no parameters to explain.

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 specifies the verb 'Get' and the resource 'owner's engineering diary', and enumerates the content (incidents, root causes, fixes, guards) with pattern tags. This distinguishes it from siblings like get_known_issues and get_timeline, which cover different aspects of engineering 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?

Explicitly states when to use the tool by providing example queries ('what broke and how did you fix it', 'show your hardest debugging session'). It does not explicitly name alternative tools for when not to use it, but the use cases are clear enough to guide selection.

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=true and openWorldHint=false, so the safe read-only nature is known. The description adds that the output includes 'real examples and A/B-style counterfactuals,' which is content-oriented rather than behavioral. It does not disclose any limitations or side effects, but for a zero-parameter read-only tool, this is acceptable 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?

The description is a single, front-loaded sentence: 'Get engineering principles with real examples and A/B-style counterfactuals.' Every word adds value, and there is no redundancy or fluff. It is appropriately concise for the tool's simplicity.

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 tool's simplicity (zero parameters, read-only annotation, no output schema), the description provides adequate context about what the tool returns. It mentions the type of content ('engineering principles with real examples and A/B-style counterfactuals'), which sets expectations. It lacks details about return structure or limitations, but those are not essential for such a simple read operation.

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?

There are zero parameters, so the description has no responsibility to explain parameter meanings. The schema coverage is effectively 100% (empty schema), and the baseline for zero-parameter tools is 4. The description does not need to add anything here.

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 ('engineering principles') and specifies the verb 'Get'. It adds useful detail about the output ('with real examples and A/B-style counterfactuals'), making the purpose evident. However, it does not explicitly distinguish this from sibling tools such as get_antipatterns or get_articles, so it lacks sibling differentiation.

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. It only states what the tool does, without any context about appropriate use cases, exclusions, or references to sibling tools. There is no indication of when to choose this over get_antipatterns or get_articles.

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 openWorldHint, and the description reinforces this with 'Read-only, closed world.' It adds behavioral context beyond annotations by stating that negative results (failed approaches) are included, which is not implied by the annotations alone.

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

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

Three sentences, front-loaded with the core purpose, followed by usage examples and a scope note. No wasted words; every sentence contributes unique, useful information.

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

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

With no parameters and no output schema, the description fully covers what the tool returns (with field details), its scope ('owner's'), its safety (read-only, closed world), and its inclusion of negative results. This is complete for a simple read-only listing 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 tool has zero parameters, so the schema provides no meaningful input semantics. The description appropriately focuses on the output content rather than input requirements, and the baseline for zero parameters 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 uses a clear verb ('Get') and specific resource ('owner's engineering experiments') and enumerates the content (hypothesis, command, raw result, verdict). It distinguishes itself from sibling tools by focusing on experiments and including negative results, making its purpose unambiguous.

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

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

Provides explicit trigger questions ('what did you measure', 'show me an experiment you ran') and notes that negative results are included, giving clear guidance on when to use. It does not explicitly name alternatives or when-not scenarios, but the use cases are well-defined.

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 openWorldHint=false; the description repeats this with 'Read-only, closed world.' It adds content details (status, temperature, deadlines) but these are data semantics, not behavioral traits. No contradiction, but little added behavioral context beyond 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 sentences, each earning its place: the first states purpose and content, the second gives usage examples and safety/world characteristics. No unnecessary words or fluff.

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

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

For a zero-parameter, read-only tool with no output schema and existing annotations, the description completely explains what the board contains, how to use it, and its closed-world behavior. Nothing essential is missing.

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

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

The tool has zero parameters, so the schema fully covers parameter semantics (trivially). The description adds context about the returned data, but no parameter-specific information is needed, warranting the baseline of 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 uses a specific verb 'Get' and identifies a precise resource: the owner's known-issues board. It clearly distinguishes this tool from sibling get_* tools by specifying the domain (open debt with status, temperature, deadlines).

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 states example questions the tool answers ('what's still broken' or 'what are you working on'), providing clear context for when to use it. It does not name alternatives or exclusions, but the examples are sufficient for a specialized get 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 annotations already declare readOnlyHint=true, establishing the safe read-only nature. The description adds valuable behavioral context by explaining the output includes not only a summary but also 'concrete ways to continue (contact channels, GitHub, MCP connect)', which is beyond what annotations provide. No contradictions.

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, front-loaded with the core purpose and followed by a usage directive. Every word earns its place; no fluff or redundancy. Perfectly concise for the tool's simplicity.

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 tool has no parameters, no output schema, and a simple profile-getter role, the description fully covers what it does, what it returns, and when to use it. It's complete for an agent to select and invoke 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 tool has zero parameters, so according to the rubric the baseline is 4. The description mentions what the tool returns (profile summary and nextSteps) but doesn't need to explain parameter formatting since none exist. This baseline 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 the tool's function: getting the owner's professional profile summary plus nextSteps. The verb 'get' with the specific resource 'owner's professional profile summary' precisely defines the scope, and the additional mention of 'nextSteps' differentiates it from sibling tools like get_projects or get_articles.

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 provides usage context: 'Use it as the first tool in an interview.' This gives a clear when-to-use directive, effectively guiding the agent to start with this tool when interviewing the owner. It implies this is the entry point, differentiating it from other tools that gather specific data.

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 the description adds useful behavioral detail by listing the data returned (stack, highlights, decision logs). There are no hidden side effects or caveats to disclose beyond what is said.

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 concise sentences front-load the core purpose and immediately note the optional parameter. Every word adds value, with 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?

For a simple read-only retrieval tool with one documented optional parameter and no output schema, the description fully explains what the tool returns and how to filter. No additional context is needed.

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 100% coverage for the only parameter ('filter'), including its enum values and description. The description merely echoes 'Optional filter by stack tag' without adding extra semantic nuance, so it meets the baseline for schema-covered parameters.

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

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

The description specifies the action ('Get'), the resource ('portfolio projects'), and the content returned ('stack, highlights, and decision logs'). This clearly distinguishes it from sibling tools like get_profile or get_articles.

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 states the tool fetches portfolio projects with an optional stack tag filter, giving clear context for when to use it. It does not explicitly name alternatives, but the sibling set makes the appropriate usage obvious.

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 provide readOnlyHint=true, revealing this is a safe read operation. The description adds no further behavioral context beyond the resource name, such as return format or scope, so it meets the baseline for adding minimal value alongside 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 sentence: 'Get the engineering decision timeline.' It conveys the essential purpose with no filler, maximizing clarity per word.

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?

As a zero-parameter, read-only tool, the description is adequate for understanding what it returns. However, it does not specify the timeline's content, time range, or output format, which could be relevant for selecting it among siblings, so a perfect score is not warranted.

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 the input schema's coverage is 100% (empty properties), meaning there is nothing to explain. This aligns with the baseline of 4 for tools with no parameters to document.

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 clear verb 'Get' and specifies the resource 'engineering decision timeline,' which is distinct from sibling tools like get_articles or get_commit_history. However, it does not elaborate on what the timeline contains, so it stops 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?

No usage guidance is provided; the description does not mention when to use this tool versus alternatives or any exclusions. It simply states the function without context, leaving the agent to infer applicability.

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, so the agent knows this is a safe read operation. The description adds behavioral context by specifying the return content (latency percentiles and bottleneck analysis) and the four concrete scenario types beyond what annotations provide, which is valuable for anticipating outputs.

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, efficient sentence that front-loads the action, lists scenarios, and states the output. No extraneous words 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 simulation tool with two fully described parameters and clear output summary, the description is complete enough. It lacks detailed output schema or edge cases, but given the absence of an output schema, the provided output description is adequate for an agent to invoke and interpret results. Complexity is moderate and covered.

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

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

Schema coverage is 100% with both parameters fully described including enums. The description merely restates the scenario enum values in prose without adding meaning beyond the schema. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the tool's function: simulating a project's architecture under specific scenarios. It names concrete scenario types and specifies the output (latency percentiles and bottleneck analysis), making it distinct from sibling tools which are all retrieval/verification 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 usage context: use this when you need to understand architecture behavior under stress scenarios. While it doesn't explicitly name alternatives, the tool's simulation nature is self-evident and clearly separated from the 'get' and 'verify' sibling tools. No exclusion criteria are stated, but the purpose is unambiguous.

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?

Despite annotations already declaring readOnlyHint and openWorldHint, the description adds substantial behavioral context: it performs a live network fetch to Dev.to, returns specific fields (title, date, reactions, url) when found, and will 'honestly' return 'not found' otherwise. It explicitly states 'Read-only' reinforcing safety. 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 long, front-loaded with the primary purpose, and every sentence earns its place: it states the function, explains the mechanism (live API fetch, return fields), and gives a direct usage example. No filler or redundancy.

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

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

For a single-parameter tool with no output schema and readable annotations, the description fully covers what an agent needs: what it does, how it works (network fetch), what it returns, and when to use it. It is complete and self-contained.

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 already describes the parameter 'query' as 'Article title fragment or keyword, e.g. "agent memory" or an exact title.' The description only says 'does the owner have a published article matching the query?' which adds no new semantic meaning beyond the schema. Since schema coverage is 100%, the baseline of 3 applies.

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

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

The description clearly states the tool's purpose: 'Verify an article against the primary source (Dev.to)' and specifies the exact question it answers (does the owner have a published article matching the query?). It also distinguishes itself from sibling verification tools by focusing on articles and Dev.to, and details the output (real title/date/reactions/url or 'not found').

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 when to use the tool: 'Use it to ground claims like "he wrote about agent memory" in the platform's data instead of the portfolio's own words.' This provides a concrete use case and also an implicit 'when not to' (when you want to rely on the portfolio's own claims). It also notes it fetches the live Dev.to API, clarifying the real-time nature.

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 (readOnlyHint, openWorldHint), the description adds valuable behavioral detail: it is deterministic and returns evidence records with source paths and a supported verdict. This goes beyond what annotations 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 concise sentences deliver purpose, behavior, and usage without redundancy. The description is front-loaded with the core action and immediately provides actionable 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?

Given the single parameter, no output schema, and clear annotations, the description fully covers behavior, return format, and when to use. The tool is simple enough that no additional context is needed.

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 already describes the 'claim' parameter with an example, so baseline is 3. The description adds context by clarifying the claim is about the owner and will be grounded in the portfolio's data, slightly enriching the parameter's meaning.

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's purpose: grounding a claim about the owner against portfolio data. It lists the specific data sources used and distinguishes itself from sibling verify_* tools by the 'about the owner' 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?

It explicitly says to use the tool before asserting a fact about the owner or to check what an answer was based on. This provides clear contextual guidance and implies exclusion of other verify tools for owner-related claims.

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 openWorldHint. The description adds behavioral specifics: it checks against the primary source, returns 'honest not found' for non-existent packages, and evaluates owner membership. This goes 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 concise and front-loaded with the core purpose. It consists of four short sentences, each adding meaningful information: purpose, usage context, not-found behavior, and safety profile. No filler or redundancy.

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

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

For a simple read-only tool with one parameter, the description is fully sufficient. It explains the source, the data returned, the use case, and the honest not-found behavior. Since there is no output schema, it adequately covers return expectations by listing the checked attributes.

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 one parameter with a clear description and example (100% coverage). The description does not add additional parameter-level semantics beyond what the schema already provides, so the baseline of 3 applies.

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

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

The description clearly states the tool verifies an npm package against registry.npmjs.org, listing specific data points (existence, latest version, publish date, etc.). The verb 'Verify' and resource 'npm package' distinguish it from siblings like verify_article and verify_repo.

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 an explicit use case: to ground claims about published npm packages in registry data rather than portfolio data. However, it does not name alternative tools or explicitly say when not to use it, only implies it.

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

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

Beyond annotations (readOnlyHint, openWorldHint), the description adds substantial behavioral context: it performs a network fetch, cross-checks with the portfolio's project record for language/stack agreement, and returns README text truncated to ~1200 chars. It explicitly reiterates 'Read-only, open world (network fetch)', reinforcing the annotation with concrete detail.

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 compact, densely informative paragraph (~80 words) with no wasted words. It front-loads the core purpose, then adds usage guidance and safety hints, with each sentence contributing a distinct piece of 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?

Given the lack of an output schema, the description adequately lists returned metadata fields (exists, language, description, topics, stars, last push) and README text, but does not specify the format or structure of the cross-check result (e.g., a boolean or verdict). It also omits error behavior for missing repos, slightly limiting completeness 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 100%, so the parameters are already well-documented. The description adds marginal context about how 'repo' is used in cross-checking and the 'readme' parameter's effect, but these are behavioral rather than semantic additions. No contradictions or gaps requiring 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 states the tool's purpose with a specific verb ('Verify a GitHub repository against the primary source') and resource. It distinguishes itself from sibling verification tools (verify_claim, verify_article, verify_package) by focusing on live repo metadata and README cross-checking, making its 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?

Explicit usage examples are provided ('Use it to ground claims like "the repo is Python" or "he maintains mscodebase-intelligence"'), giving clear context for when to apply the tool. It does not explicitly name alternatives or state when not to use it, but the specificity of repo verification implies boundaries relative to other verify tools.

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