linkdapi-the-best-linkedin-professional-data-api

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

No annotations are provided, so the description must carry the full burden. It mentions billing cost ('1 Credits') but omits other behavioral details such as authorization needs, pagination behavior, or what happens with large result sets. This is a minimal disclosure.

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

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

The description is two concise sentences with the purpose front-loaded. There is no redundant elaboration, and the billing note is a useful addition without adding clutter.

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 output schema and no annotations, the description is incomplete. It fails to explain the 'start' parameter, pagination, response format, or any usage limits beyond billing. The tool is simple, but the description leaves critical 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 description explains that 'urn' is used to identify the profile, which adds meaning to that parameter. However, 'start' is not mentioned at all, and schema coverage is 0%, leaving the agent without any clue about pagination or offset semantics.

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

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

The description clearly states the action ('Get all'), the resource ('Articles'), and the scope ('for given profile by urn'). This distinguishes it from sibling tools like get_api_v1_articles_article_info and get_api_v1_articles_article_reactions, which target specific article details rather than all 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 implies this tool is for retrieving all articles for a profile, which is clear context. However, it does not explicitly state when to use this over sibling tools like article_info or article_reactions, nor does it mention alternatives or 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?

No annotations are provided, so the description must disclose behavioral traits. It mentions billing cost ('Billing per call: 1 Credits'), which is useful, but does not indicate read-only nature, rate limits, or any side effects. The description is too brief to fully convey behavior.

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

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

The description is extremely concise: two short sentences. Every word earns its place. It is front-loaded with the core function, and the billing note is a useful extra. No 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 tool with a single parameter, no output schema, and no annotations, the description is minimal but might be adequate given simplicity. However, it lacks context on expected response format, error cases, or usage examples. Given the tool's simple nature, a 3 might be arguable, but the lack of any parameter guidelines and behavioral notes makes it incomplete.

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

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

The schema has one parameter 'url' with zero description coverage. The description adds minimal value by saying 'Get article by url' and providing an example in the schema, but it does not explain what format the URL should be in, whether it must be a LinkedIn article, or other constraints. Since coverage is 0%, the description should compensate but does 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 'Get article by url' clearly states the action and target resource. It distinguishes from siblings like get_api_v1_articles_all (list all) and get_api_v1_articles_article_reactions (reactions), by specifying it's for a single article by URL.

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 guidance on when to use this tool versus alternatives. It does not specify that it retrieves a specific article, nor does it mention alternative tools for listing or searching articles. The context is implied but not 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 are absent, so the description must carry the burden of behavioral disclosure. It only states the billing per call and implicitly that it's a GET request, but does not explain pagination (the 'start' parameter), response format, or whether any rate limits apply. The description is silent on these behavioral aspects.

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, consisting of two short sentences. While it is not bloated, it lacks substantive detail. It does include useful billing information, but the brevity comes at the cost of missing important context. It is efficient but under-informative.

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 there is no output schema and only two parameters, the description should explain what the response contains, how pagination works, and any dependencies on other endpoints. None of this is covered. The tool appears simple, but the lack of return-value details and parameter usage makes it incomplete for a user to invoke correctly without external knowledge.

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 50% (only 'urn' has a description). The description does not add any parameter semantics beyond what is in the schema. The 'start' parameter is undocumented in both the schema and description, leaving a gap that a good description should fill. It does not clarify how 'start' is used for pagination or offsets.

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

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

The description clearly states the action ('Get article reactions') and specifies the resource scope ('Group: articles'). This distinguishes it from other article-related tools like get_api_v1_articles_all and get_api_v1_articles_article_info, though it could be confused with reactions on other entities, the 'Group: articles' qualifier resolves that.

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 guidance is provided on when to use this tool versus alternatives like get_api_v1_posts_likes or get_api_v1_profile_reactions. There is no mention of prerequisites, such as needing to obtain the URN from the articles info endpoint, even though the parameter schema hints at this. The description offers no decision 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?

The description mentions billing cost (1 credit) but does not disclose other behavioral traits such as read-only nature, rate limits, or side effects. With no annotations, more transparency is expected.

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 (one sentence) but contains awkward phrasing and a typo, hindering clarity. It is not well-structured for the intended 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?

No output format, pagination behavior, or detailed use case is described. The description is skeletal and does not adequately support an agent in understanding the tool's full behavior.

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 description partially explains 'urn' as identifying the profile but leaves 'cursor' entirely unexplained. Since schema coverage is 0%, the description should clarify both parameters, but it falls short.

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 tool fetches all comments for a profile identified by URN, but the phrasing 'but its URN Group: comments' is confusing and contains a likely typo. It conveys the main action but lacks 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?

No guidance is provided on when to use this tool over alternatives (e.g., get_api_v1_posts_comments or get_api_v1_comments_likes). The description lacks usage context or prerequisites.

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

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

No annotations are provided, so the description must fully disclose behavioral traits. It only mentions 'Billing per call: 1 Credits' which is a cost-related behavior, but it does not state that this is a read-only operation, any authentication requirements, pagination behavior, or other effects. The disclosure is minimal.

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 plus a billing note. It goes straight to the point, avoids fluff, and is well-structured for quick scanning. Every word contributes to the core purpose or cost.

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 two parameters (both optional), no output schema, and no annotations, the description should have provided details on the 'start' parameter (pagination), the acceptable format of 'urn' (multiple values?), and what the response contains. It only covers the primary function, leaving the agent to guess about pagination and output, making it incomplete.

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

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

The schema has 0% description coverage, and the description does not compensate. It only mentions that the comment is identified 'by URN', but does not explain the 'start' parameter at all (likely for pagination). The example shows comma-separated URNs, but this is not described. The description adds no meaningful meaning beyond the raw schema examples.

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 'get all likes for given comment by URN' with a clear verb ('get') and resource ('likes for given comment'), and it specifies the identifier ('by URN'). This distinguishes it from siblings like get_api_v1_posts_likes and get_api_v1_comments_all, so 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 purpose implies usage (to fetch comment likes), but the description provides no explicit guidance on when to use this tool versus alternatives, no exclusions, and no context about prerequisites or typical scenarios. It only states the action and billing, so guidance is merely implied.

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

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

No annotations are provided, so the description carries the burden. It mentions billing per call (1 credit) but doesn't disclose response format, pagination, or any side effects. For a read operation, it's minimal.

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 action. The billing note is extra but useful. 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?

Given the tool's simplicity (one param, no output schema), the description is adequate but lacks details on what 'affiliated pages' means or how results are returned. It's minimally complete.

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

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

Schema coverage is 100% with the 'id' parameter described as 'Company ID'. The description adds no extra meaning beyond the schema, so 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 states the tool retrieves affiliated pages for a company by ID, which is a specific verb+resource. It distinguishes from siblings like company_info or company_posts, though it doesn't explicitly contrast them.

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 when needing affiliated pages for a company, but provides no explicit when-to-use or alternatives. It doesn't mention exclusions or prerequisites beyond the company ID.

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

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

With no annotations present, the description carries the full burden, and it does add one meaningful piece of operational context: 'Billing per call: 1 Credits,' which an agent would want to know before invoking. However, nothing is disclosed about the read-only nature, response format, authentication needs, or rate limits. The cost disclosure earns partial credit, but it's thin for an unannotated endpoint.

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 sentence packing three facts (what to get, group, billing), which is appropriately brief. However, it contains a crude duplication error ('Get company Get campany') and a misspelling ('campany'), detracting from overall quality. Front-loaded enough, but the sloppiness keeps it from scoring higher.

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 tool with 1 parameter, no nested objects, and no output schema, the description is close to sufficient. However, 'Employees Data' is vague — an agent is left wondering what fields are returned and why this differs from company_info or company_insights. Adequate but not rich enough to fully compensate for the lack of an output 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 coverage is 100% — the single parameter 'id' is described as 'company ID' with an example '1441' — so the baseline of 3 applies. The description adds nothing beyond a redundant 'By ID' and does not clarify id validity, format constraints, or edge cases. Meets the minimum bar without enhancing parameter 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 verb+resource: 'Get company Employees Data By ID', which is specific enough to understand what the tool fetches. While it doesn't explicitly distinguish itself from siblings, the 'Employees Data' resource is distinct from 'company_info' or 'company_insights' tools in the sibling list. Minor typos ('campany') and a duplicated 'Get' slightly muddy an otherwise clear 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?

There is no guidance on when to use this tool versus its ~50 siblings — no explicit when/when-not, no prerequisites, no alternatives named. 'Group: Companies' merely categorizes the tool rather than disambiguating it. For a tool with so many siblings, some usage direction would be critical, but it's entirely absent.

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

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

No annotations are provided, so the description carries the full load for behavioral disclosure. It mentions billing cost ('Billing per call: 1 Credits'), which is a useful contextual detail, but it fails to disclose basic behavioral traits like whether the operation is read-only/read/other, the nature of the returned data, potential errors (e.g., what happens if neither id nor name is provided), or rate limits. The description is too thin for a tool that isn't annotated.

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 succinct, at two sentences totaling under 100 characters. It front-loads the core purpose (Get company details) and immediately states the flexible identification method, followed by the billing note. Every word adds value; there is no fluff 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?

Despite having no output schema, no annotations, and only 2 params (which are fully described), the description fails to cover critical aspect: the expected return structure of 'company details' (e.g., does it include name, industry, location, etc.?), the behavior when both id and name are given, and error scenarios when neither is provided. A tool like this could easily return a single company object but with nested data, and the description gives no hint of what to expect.

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

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

Schema description coverage is 100%, so the schema already fully describes 'id' and 'name' with examples. The description adds the concept that 'either by ID or name' is acceptable and indicates mutual exclusivity, which goes slightly beyond the schema's separate field descriptions. However, it does not clarify parameter format (e.g., whether both can be provided together) or tie the parameters to potential behaviors (e.g., which takes precedence). Given the complete schema, a 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 the tool retrieves company details by ID or name. The verb 'Get' followed by 'Company Details' and the explicit 'By ID or name' makes the purpose concise and unambiguous. It's easily distinguished from sibling tools like get_api_v1_companies_company_posts which fetch related content.

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 tools description implicitly indicates this is a single-entity lookup endpoint (by ID or name), which contrasts with sibling tools like get_api_v1_search_companies that perform search operations. However, there is no explicit exclusion statement like 'do not use for searching' or pointer to an alternative for broader search needs, which would make it 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?

With no annotations, the description carries the full transparency burden. It discloses paid-plan exclusivity and credit cost, but the credit amount is internally inconsistent (3 credits vs. 1 credit), and it omits return behavior or side effects.

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

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

The description is short, but it includes redundant and contradictory billing information plus a low-value 'Group: Companies' line. It is somewhat concise but not every detail 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?

The tool has no output schema, no annotations, and a single parameter, yet the description still provides minimal context about what the response contains or why 'insights' differs from other company endpoints. Credit and paid-plan info helps, but the overall picture is incomplete.

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

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

Schema description coverage is 100%, so the schema already explains the only parameter, 'id'. The description adds no additional semantic detail about how the ID is used or what values are valid.

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 company insights, using a specific verb and resource. However, it does not differentiate what 'insights' includes compared to sibling company tools like company_info or company_employees_data.

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 guidance is given on when to use this tool versus alternative company endpoints. The credit cost and paid-plan restriction are mentioned, but these are access constraints, not usage direction.

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

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

No annotations exist, so the description carries the full burden of behavioral disclosure. It does note the per-call cost and implies a read operation, but does not disclose return shape, pagination, or potential errors/limits.

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 gets to the point, with a short sentence followed by two terse metadata labels. There is no filler. Slight grammatical issues like 'Posts By ID' do not severely hurt clarity.

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 only two parameters and no output schema, but the description is still too sparse. It does not explain what the response contains, how 'start' is used, or whether 'id' is effectively required, which could cause invocation errors.

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 description adds no parameter semantics. The schema gives the 'id' field a description ('company ID') but leaves 'start' with only an example of '0'. The description does not compensate for this gap, leaving the meaning of 'start' unclear.

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

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

The description states a specific action and resource: 'Get company Posts By ID', which aligns with the tool name and distinguishes it from company info or employee tools. However, it does not explicitly disambiguate from the more general post tools like get_api_v1_posts_all or get_api_v1_posts_info.

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 only includes 'Group: Companies' and billing information, with no mention of when to use this tool versus alternatives or any prerequisites such as requiring a company ID.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only mentions billing per call, but does not describe authentication needs, return format, pagination, or what 'similar' means. The read-only nature is implied by 'Get' but not explicitly disclosed.

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

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

The description is extremely concise, front-loads the core purpose, and includes only one additional piece of useful information (billing cost). Every sentence earns its place, and 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?

The tool is simple with one fully documented parameter, so the description is minimally viable. However, with no output schema and no annotations, it does not explain what the response contains, how many similar companies are returned, or any additional behavior. For a simple read endpoint, this 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 fully documents the single parameter 'id' with a description and example, so schema coverage is 100%. The description adds no additional parameter semantics beyond saying 'by ID', which is redundant with 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 clearly states the action ('Get Similar companies') and the resource ('by ID'), which distinguishes it from sibling tools like company info, posts, or employees. The title reinforces the purpose, and the 'Group: Companies' adds context.

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 guidance is provided on when to use this tool versus alternatives such as get_api_v1_companies_company_info or get_api_v1_search_companies. The description implies usage through the name but gives no context, exclusions, or alternative recommendations.

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

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

No annotations are provided, so the description carries the full burden. It does not disclose side effects, permissions, rate limits, or whether the operation is read-only. The mention of billing credits is the only behavioral note, but it is sparse.

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 (one sentence plus group and billing metadata) and well-structured. It avoids superfluous content, though it could be slightly more detailed without becoming verbose.

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 implies a return value ('Get Company ID') but does not specify the output format, possible errors, or any additional behavior. Given the lack of an output schema, this minimal explanation leaves gaps for the 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 only parameter, universalName, is briefly described as '(username)' in the description, but the schema lacks a description field. The example 'google' is present, but the meaning and format of a universalName are not explained beyond being a username.

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 function's purpose: 'Get Company ID by its universalName.' The verb 'Get' and resource 'Company ID' are explicit, and it distinguishes from siblings by specifying the universalName-to-ID conversion.

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 minimal usage context. It mentions 'Group: Companies' and billing cost, but does not offer guidance on when to use this function versus alternatives, nor does it describe prerequisites or scenarios.

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

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

With no annotations, the description carries the full burden of disclosing behavior. It mentions billing ('Billing per call: 1 Credits') but does not reveal whether this is read-only, what the response shape is, or if there are any side effects or limitations. The read-only nature is assumed from the GET-style name, but not explicitly stated, and no other behavioral traits are disclosed.

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

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

The description is a single sentence, which is concise, but it contains a typo ('comanies') and an unnecessary 'Group: Companies' fragment that adds noise. The billing note is useful, but the overall structure feels rushed and unpolished.

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 list endpoint, the description is incomplete. It does not mention pagination, response format, or any filtering beyond company IDs. With no output schema and no annotations, the agent is left without key operational details, making the description insufficient for fully safe and 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?

Schema description coverage is only 50% (only companyIDs has a description). The description reinforces that companyIDs are IDs, but it does not clarify the 'start' parameter, which likely relates to pagination or offset. The description adds minimal value beyond the schema and does not compensate for the undocumented parameter.

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

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

The description clearly states the action: 'get available jobs for given companies by ID'. It identifies the resource (jobs) and the scope (by company IDs), which is sufficiently specific. However, it does not explicitly distinguish this from sibling tools like get_api_v1_jobs_search, which also deals with jobs, but the company-ID scoping does provide some 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 such as get_api_v1_jobs_search or get_api_v1_companies_company_posts. There is no mention of use cases, prerequisites, or exclusions, leaving the agent to infer usage context from the tool name and sibling list.

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

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

No annotations are present, so the description carries the full burden. It discloses the core operation (search by name) and cost ('Billing per call: 1 Credits'), which is useful beyond structured fields. However, it does not specify the return format, whether query is required despite schema showing 0 required params, pagination, or any rate limits—leaving notable gaps for a no-annotation tool.

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

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

The description is very short and front-loaded: one clear functional sentence followed by a concise billing note. The 'Group: Companies' segment is somewhat redundant given the tool name, but it does not add significant bloat. Overall, it is economical 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?

Given no output schema, no annotations, and a single parameter, the description should explain what the lookup returns (e.g., company objects, IDs, matching names) and any behavior on empty queries. It currently only states the search action and cost, leaving key usage context missing for an agent to gauge expectations or handle errors.

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% with the query parameter described as 'the search query it can be 1 char or multiple.' The tool description adds meaningful semantic context by clarifying that the query is a company name ('search companies by name'), which enhances the schema's generic definition.

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: 'search companies by name.' This is a specific verb + resource with a clear scope (by name), which distinguishes it from broader search tools like get_api_v1_search_companies, though it does not explicitly name alternatives or edge cases.

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 name-based company lookup via the verb and resource, but it provides no explicit guidance on when to choose this tool over sibling tools like get_api_v1_search_companies or get_api_v1_companies_company_universal_name_to_id. There are no exclusions or alternative recommendations, but the intent is reasonably inferable.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only mentions billing per call (1 credit) but doesn't clarify if this is a read-only operation, what the response format is, or any potential side effects. There is no mention of rate limits or whether it returns partial matches, which is relevant for a search tool.

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

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

The description is very brief, with one functional sentence and a billing note. It is front-loaded with the core purpose, and there is no wasted text. However, the phrasing is a bit clunky ('get The geo Ids' with capital T), and the billing info is included in the same sentence, which could be separated for clarity but is still concise.

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 there is no output schema, no annotations, and only one parameter, the description should provide more context about what the tool returns (e.g., a list of geo IDs with location names?) and any limitations (e.g., max results). The description is minimal but the tool is simple, so some gaps are acceptable. However, it lacks enough detail for an agent to fully understand the response structure or how to handle errors.

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 one parameter 'query' with a description: 'the search query it can be 1 char or multiple'. The description of the tool adds nothing beyond this, as it already covers the semantics. Schema coverage is 100%, so baseline 3 applies. It does not add examples or clarify the expected format, but the schema's example 'Washington' is helpful. No additional meaning is provided.

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 says 'search locations and get The geo Ids', which conveys the verb and resource, but it's somewhat awkward ('The geo Ids') and lacks a clear distinction from other lookup tools like companies_name_lookup. It could be more specific about what kind of locations (e.g., cities, countries) and what the geo Ids represent.

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 that this is meant for location searches to obtain geo IDs, but it does not explicitly state when to use this tool versus sibling lookup tools (e.g., companies_name_lookup for company IDs, g_services_lookup for services). No exclusions or alternatives are mentioned, but the 'Group: geo' hint provides some 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?

Without annotations, description discloses the cost ('Billing per call: 1 Credits') and that it returns service IDs, implying a read-only lookup. However, it omits auth requirements, pagination, response format, or rate limits.

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 action and resource. Minor issues: misspelling 'relevent' and cryptic 'Group: services' fragment detract slightly.

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 single-param lookup, it covers the basic function and billing, but lacks return shape, usage context vs siblings, and query parameter constraints. Adequate but with clear 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?

One parameter (query) has no schema description; description adds that it is a keyword for searching services. But doesn't clarify optionality (schema has required: 0) or accepted syntax/format.

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?

Clearly states a search/lookup action on services producing IDs. The verb 'search' and resource 'services' are explicit, but it doesn't differentiate from sibling get_api_v1_search_services.

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 guidance on when to use this over get_api_v1_search_services or service detail endpoints. Usage is only implied as keyword lookup.

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

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

With no annotations provided, the description must carry the behavioral burden. It discloses billing ('1 Credits per call') which is a cost consideration, but it does not mention side effects, authentication, rate limits, or absence of destructive actions. The tool appears read-only from the name, but this is not explicitly stated.

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, consisting of two short sentences that convey the core purpose and billing. Minor issues include a typo ('relevent') and the cryptic 'Group: skills' phrase, but overall it is efficient and front-loaded.

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

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

For a low-complexity tool with one parameter and no output schema, the description covers the essential aspects: what it does, what it returns (skills and titles with IDs), and cost. It does not elaborate on result formatting or limitations, but given the simplicity, this is adequate.

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 only provides a 'query' string with an example. The description adds meaning by stating it is a 'keyword' used for searching, which clarifies its role. However, it does not specify whether the parameter is required or any constraints (e.g., max length), leaving some ambiguity given 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 clearly states the tool searches for a keyword and returns relevant skills and titles with their IDs. It uses a specific verb ('search') and specifies the resource ('skills and titles'). It distinguishes from siblings like services lookup by mentioning 'skills' explicitly, though the parenthetical 'Group: skills' is ambiguous.

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 looking up skills and titles based on a keyword, but it does not explicitly state when to use this over alternative lookup tools (e.g., services lookup). No when-not or alternative tools are mentioned, so usage guidance is minimal.

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

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

No annotations are provided, so the description carries the full burden. It discloses billing cost ('Billing per call: 1 Credits') but omits return format, failure behavior, and the open-job requirement, which only appears in the schema parameter description.

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 with no filler. It front-loads the core action and includes the useful billing detail, making every sentence earn 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?

The tool is simple, but with no annotations and no output schema, the description should explain more about what 'job details' includes and the open-job constraint. It currently relies entirely on the schema for critical usage 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 100% and the jobId parameter is already described in the schema. The tool description adds no additional parameter meaning beyond restating 'by jobId'.

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

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

The description states a specific verb and resource: 'get Job details by jobId'. It is clear and distinct from the sibling tools, though it does not explicitly differentiate itself from related job tools like job_similar or job_people_also_viewed.

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 when you have a jobId, and the schema adds the important constraint that the job must be open and actively hiring. However, the description itself provides no explicit when-to-use guidance or alternatives.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only mentions 'Billing per call: 1 Credit' and does not describe whether this is read-only, what fields are returned, how authentication works, or what errors might occur. This is minimal disclosure for a tool with no annotation safety hints.

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 puts the main action first, but it is poorly worded and grammatically awkward. 'Group: jobs' is an unnecessary fragment, and 'Billing per call: 1 Credits' is useful but appended without clear structure. It is short, but it is not well-written or cleanly organized documentation.

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 one parameter, no annotations, no output schema, and no schema descriptions, this tool description leaves important gaps. It explains the general purpose and cost, but the agent still needs detail about whether jobId is mandatory, what the return shape is, and what behavior to expect if no related jobs exist. The description is minimally usable but not complete for reliable 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?

The schema provides only a jobId string with an example but no description, and the schema description coverage is 0%. The tool description does not explain that jobId identifies the source job whose people-also-viewed recommendations should be retrieved, nor does it clarify whether jobId is required. The phrase 'Group: jobs' does not compensate for this missing parameter guidance.

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 core operation: retrieve related jobs that people also viewed, and the title 'People Also Viewed' supports this. It does not explicitly contrast itself with get_api_v1_jobs_job_similar or get_api_v1_jobs_job_details, but the 'people also viewed' wording is specific enough to indicate a distinct resource. The fragment 'Group: jobs' adds little value.

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 guidance about when this tool should be used instead of sibling tools like get_api_v1_jobs_job_similar, get_api_v1_jobs_job_details, or get_api_v1_jobs_search. No conditions, prerequisites, or exclusions are provided, so an agent must infer the intended use case from the name and title 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?

No annotations are provided, so the description carries the full burden. It only mentions 'Billing per call: 1 Credits' which is a useful cost disclosure, but it does not describe read-only behavior, response format, pagination, or any side effects. For a tool with no annotation coverage, this is insufficient.

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 with three pieces of information: purpose, group, and billing. It is compact and front-loaded. However, the typo and awkward capitalization ('Jobs') reduce polish, and 'Group: jobs' is somewhat extraneous.

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 tool, the description gives the core action but lacks context about what the response contains, any limitations, or how 'similar' is defined. With no output schema, the description should explain return values but does not. It feels incomplete for an agent needing to know what to expect.

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 a single parameter 'jobId' with 0% description coverage. The description says 'By Job ID' which just repeats the parameter name without adding format, requiredness, or how to obtain the ID. It adds minimal value beyond 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 states 'Get siilar Jobs By Job ID' which clearly indicates the tool retrieves similar jobs based on a job ID. The typo 'siilar' slightly detracts but the intent is unambiguous. It distinguishes itself from siblings by focusing on 'similar' jobs, though it doesn't explicitly contrast them.

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 siblings like get_api_v1_jobs_job_people_also_viewed or job_details. There is no mention of use cases, prerequisites, or alternative 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?

No annotations are provided, so the description carries the full burden. It mentions billing cost ('1 Credits') but does not disclose whether the operation is read-only, any authentication requirements, rate limits, or side effects. The term 'search' suggests a safe read, but that is not explicitly stated.

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

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

The description is very short and to the point, containing only the essential action and a billing note. It avoids fluff, but it could be slightly richer without becoming verbose; still, it is appropriately concise.

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 schema fully documents parameters, and there is no output schema, so return values need not be detailed. However, the description does not mention any edge cases, response format, or high-level behavior beyond 'search jobs', leaving some contextual gaps for a complete understanding.

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 100% coverage with detailed descriptions for each of the 11 parameters, including examples, allowed values, and formatting. The tool description adds no additional parameter information, so the baseline score 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 'search jobs' which identifies the verb and resource, and it is distinct from sibling search tools (e.g., search_people, search_companies). However, it lacks any detail about the specific filtering capabilities or the intended use case beyond the literal name.

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. While the name 'search jobs' implies the domain, there is no explicit comparison to sibling tools or mention of scenarios where this tool is preferred.

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

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

With no annotations, the description must carry the burden of disclosing behavior, but it only mentions billing per call and group. It does not state whether it is read-only, pagination behavior, rate limits, or what data is returned (post metadata? content?).

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 are concise and front-loaded with the core purpose. However, the second sentence ('Group: Posts. Billing per call: 1 Credits') is low-value metadata that could be omitted or placed in annotations.

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 relatively simple with 3 params and no output schema, but the description fails to state expected return format or pagination details. Since annotations are absent, more context is needed to fully guide usage.

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, but it only mentions 'urn' implicitly ('using its URN') without explaining 'start' and 'cursor' as pagination controls. The parameter examples are in the schema, but the description adds no extra 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 states the tool fetches all posts for a given profile URN, which is clear, but it lacks specificity about filtering or pagination and does not differentiate among sibling tools like get_api_v1_posts_info or get_api_v1_posts_featured beyond the 'all' keyword.

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 guidance is provided on when to use this tool over alternatives, such as when retrieving all posts versus specific post details or featured posts. The description mentions 'For a given profile' but does not explain prerequisites or when not to use it.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states 'get all comments' but does not reveal that pagination is likely via cursor/start/count, nor any authentication requirements, rate limits, or side effects. The statement 'get all' could mislead an agent into expecting a single full response without pagination.

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, stating the core function in the first sentence. It avoids unnecessary filler. However, it may be too brief given the tool's complexity, but for conciseness alone it earns a high score.

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 four parameters, no output schema, and no annotations, the description is inadequate. It fails to explain pagination, post identification, or return structure. The tool appears simple but likely involves cursor-based pagination, which is not addressed, leaving the agent under-informed.

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%, meaning the description must compensate by explaining parameters. However, it does not mention any of the four parameters (urn, count, start, cursor) or their roles. The agent is left without guidance on which parameter identifies the post or how pagination works, rendering the tool difficult to use correctly.

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 fetches all comments for a given post, which distinguishes it from sibling tools like get_api_v1_comments_all (all comments) and get_api_v1_posts_all (posts). The title 'Post's Comments' reinforces the purpose, making the primary function 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?

There is no explicit guidance on when to use this tool versus alternatives. The description does not mention exclusions, prerequisites, or scenarios where other comment-related tools might be preferred. The 'for a given post' phrase implies usage context but does not instruct the agent on selection criteria.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It mentions billing (1 Credit) but lacks details on pagination, error handling, or the nature of 'featured' posts. The read-only nature is implied by 'Get,' but not explicitly stated, and there is no discussion of potential side effects or limits.

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 immediately followed by relevant metadata (Group and Billing). It is front-loaded, contains no fluff, and every part serves a purpose.

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

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

The tool is simple with one parameter, and the description covers the core purpose. However, there is no output schema or mention of response format, pagination, or what 'featured' means in this context. For a minimal GET endpoint, it is adequate but leaves some ambiguity for the 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 schema has 0% description coverage for the 'urn' parameter, but the tool description clarifies that the URN belongs to a profile. This adds some meaning beyond the plain schema, though it does not elaborate on format, constraints, or how to obtain the URN. Given the low coverage, this slight compensation earns a middle score.

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 'Get all featured posts for a given profile using its URN,' specifying the verb, resource (featured posts), and scope (profile URN). It distinguishes from siblings like get_api_v1_posts_all by explicitly mentioning 'featured,' making the purpose unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives like get_api_v1_posts_all or get_api_v1_posts_info. It merely states the function without mentioning exclusions, prerequisites, or context for selection among the many post-related 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?

No annotations are provided, so the description carries the behavioral burden. It indicates a read-only retrieval via "Get" and notes billing, but it does not disclose output contents, error conditions, authentication requirements, or rate limits. This is a minimally acceptable disclosure for a simple get-by-URN tool.

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 and front-loaded with the core action: "Get post info using its URN". The additional metadata threads (Group, Billing) are short and non-redundant. 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?

Given a very simple 1-parameter tool with no annotations and no output schema, the description is minimally complete: it states the source, input, and cost. However, it lacks any guidance about expected output shape, where to get the URN, or distinctions from sibling post endpoints, making it 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%, and the description only says "using its URN". It adds no meaning beyond the already-named parameter `urn`; it does not explain what a URN is, how to obtain it, or whether it refers to a LinkedIn post URN. A basic example existed in the schema but no semantic enrichment.

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?

"Get post info using its URN" clearly states a specific action with a specific input, distinguishing this from sibling post-related tools like get_api_v1_posts_all or get_api_v1_posts_comments. The scope is precise: retrieving one post's information by URN.

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: when you have a URN of a post and need its info. There is no explicit when-to-use vs alternatives or exclusions, though it is clear enough for the narrow purpose. It does not state that this tool should not be used for comments, likes, or all posts.

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

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

With no annotations, the description carries the full burden, but it only adds billing information ('1 Credits') and the vague claim of returning 'all people.' It does not disclose pagination behavior, response shape, required authorization, or whether 'all people' is truly unpaginated given the presence of a 'start' parameter.

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

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

The description is short and front-loaded, with the core purpose in the first sentence. The billing and group metadata are compact and add some operational context, though the overall content is thin.

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 two-parameter list endpoint with no output schema and no annotations, the description is under-specified. It omits pagination semantics, parameter roles, and any details about the returned data, making it insufficient for reliable tool 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%, and the description does not explain either parameter. 'urn' is not identified as the post identifier, and 'start' is not explained as a pagination offset, leaving the agent to guess from examples 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 states a clear action and resource: 'get all people that reacted a post,' which aligns with the title 'Post's likes.' It is distinguishable from sibling tools like get_api_v1_comments_likes by the resource type (post vs comment), though it does not explicitly differentiate itself.

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 guidance is provided on when to use this tool versus alternatives. The 'Group: Posts' label gives weak contextual placement, but there are no explicit use cases, prerequisites, or 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only names the kind of data (last update, verification info) and notes billing, but does not disclose side effects, required permissions, potential errors, readonly nature, or the response shape. This is insufficient for a tool whose endpoint group has many similar read operations.

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

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

The description is short, but it wastes tokens on 'Group: Profile' and the billing line, which do not help the agent. The useful part is limited to 'about this profile such last update and verification info'. It is under-specified rather than efficiently structured.

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 one parameter, no output schema, and no annotations, the description must be richer to be useful. It provides only a partial content overview and omits return values, error conditions, and parameter meaning. The tool name suggests it is a read operation, but the description is too thin to give the AI agent enough context to confidently select and use 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?

The schema defines one parameter, 'urn', with an example but no explanation, and schema description coverage is 0%. The description does not mention the urn parameter at all or explain how to identify the target profile. It fails to compensate for the missing schema documentation, leaving the agent without semantic guidance for this required input.

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 ('this profile') and specific content ('about this profile such last update and verification info'), which clarifies it returns 'about' data for a profile. The endpoint name and title reinforce the 'get' semantics, but the description itself lacks an explicit verb and does little to distinguish this from the many other profile_* siblings beyond the word 'about'.

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 guidance on when to use this tool versus alternatives such as get_api_v1_profile_overview or get_api_v1_profile_full. The 'Group: Profile' and billing note are not usage guidelines; they neither describe prerequisites nor mention 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 are absent, so the description carries the full burden of behavioral disclosure. It only adds billing cost and the URN group scope; it does not clarify read-only behavior, authentication needs, pagination, error conditions, or response shape. While not contradictory, the disclosure is minimal for a tool with no annotation support.

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

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

The description is very short and the billing sentence adds useful cost information. The main sentence is grammatically odd ('Get Lists professional certifications') but not bloated; it is concise at the cost of polish.

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

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

For a one-parameter retrieval tool with no output schema and no annotations, the description under-delivers: it does not state the return format, any limits, or whether the URN is optional given that no parameters are required. The billing note helps, but the description leaves too much unspecified for confident 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%, and the single 'urn' parameter is undocumented in the schema. The description's phrase 'by URN Group: Profile' adds some meaning by indicating that the URN identifies a profile, but it does not explain requiredness, format, or what happens if no matching profile exists.

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 action as listing professional certifications and scopes them to the Profile URN group, which distinguishes it from sibling profile tools like profile_education or profile_skills. The phrasing 'Get Lists professional certifications' is grammatically awkward but clear enough that the tool returns certifications for a profile.

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 explicit guidance on when to use this tool instead of sibling profile tools, no exclusions, and no mention of alternatives. The phrase 'by URN Group: Profile' weakly implies it is for a specific profile's certifications, but the description does not help an agent choose between this and similar profile endpoints.

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

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

With no annotations, the description carries the full burden. It discloses a read-like action ('Get') and billing cost ('1 Credits'), but omits auth requirements, error behavior, and response format. This is adequate for a simple read endpoint but has clear gaps.

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 with the core action and resource front-loaded. The 'Group: Profile' fragment is slightly redundant, but overall the description is efficient and free of 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?

For a single-parameter read endpoint with no output schema, the description covers the basic action and cost. However, it lacks usage alternatives and parameter semantics, making it minimally complete but not fully informative for an agent navigating many similar profile 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% and the sole parameter has no description. The description only restates that lookup is 'by username,' adding no format, constraints, or examples beyond what the parameter name and schema example already provide. It fails to compensate for the low schema 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 a specific verb ('Get') and resource ('contact details for a profile by username'), which clearly distinguishes it from sibling profile endpoints like about, details, full, and skills. The 'Group: Profile' and billing notes do not obscure the core 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?

No guidance is given on when to use this tool versus the many sibling profile endpoints. The only usage context is 'by username,' which is already evident from the tool name and parameter, so the description provides no exclusions or 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?

With no annotations, the description carries the full burden. It only says 'Get profile details' and mentions billing credits, but does not disclose any side effects (though it implies read-only), data returned, error handling, or rate limits.

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 to the point, with no unnecessary verbosity. The billing note adds useful context without bloating the text.

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

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

The tool is simple (one parameter, no output schema), but the description omits crucial details such as what 'profile details' includes, what the response format is, and any potential error conditions. It is not sufficiently complete for an agent to confidently use it.

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 sole parameter 'urn' has only an example, and the description does not explain what a URN is or how it relates to the profile. The schema coverage is minimal, and the description fails to compensate by clarifying the parameter's meaning or format.

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

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

The description clearly states the action ('Get') and resource ('profile details'), but it is somewhat redundant ('details information') and does not differentiate from other profile sub-endpoints like 'about' or 'education'.

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 guidance is provided on when to use this tool versus the many sibling tools for specific profile aspects. The description does not mention alternatives or conditions that would make this the preferred choice.

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 are absent, so the description must disclose behavioral traits. It only mentions billing per call, but gives no information about side effects, authentication requirements, rate limits, or the nature of 'full' (e.g., whether it returns all education entries or just a subset). The read-only nature is implied by 'Get' but not explicitly stated.

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 remarkably concise, consisting of two short sentences. It front-loads the core purpose and includes essential billing information. However, the brevity leaves out critical details, and the billing note could be considered secondary but is still 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?

Given the lack of annotations, output schema, and parameter documentation, the description is highly incomplete. It does not indicate what the response contains, whether further pagination is needed, or any error conditions. The phrase 'full education' is vague and could benefit from specifics like field names or coverage.

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 'urn' parameter at all. It only repeats the parameter name from the schema. The schema provides an example but no guidance on format or meaning. The description fails to compensate for the lack of parameter documentation.

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

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

The description clearly states the tool retrieves 'full education' data based on a URN. It specifies the resource (education) and the identifier (URN), making the core purpose unambiguous. However, it doesn't explicitly distinguish it from sibling tools like certifications or skills, though the name itself provides some 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?

No guidance is provided on when to use this tool versus alternatives. It doesn't mention that this should be used specifically for education history, nor does it mention any conditions or prerequisites (e.g., needing a valid URN). There is no comparison to similar profile endpoints.

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

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

With no annotations, the description carries the full transparency burden. It discloses that the response includes 'everything', which hints at a large payload, but fails to mention important behaviors such as the need to provide either urn or username (both optional in schema), auth requirements, or potential rate limits. The billing note is cost-related, not behavioral, and adds little transparency.

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 brief (one sentence plus metadata) and front-loaded with the core purpose. It avoids bloat, though the 'Group: Profile' and 'Billing per call' fragments are tangential. Overall, it is efficient and does not waste 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?

For a tool with 2 optional parameters and no output schema, the description is inadequate. It does not explain how the system selects a profile when both params are optional, what the response structure looks like, or how this 'full' response differs from other profile endpoints beyond being comprehensive. The lack of any usage or parameter guidance makes the tool poorly specified.

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, but it does not explain the parameters at all. The schema only shows optional urn and username with examples, but the description never clarifies that these are alternative identifiers or that at least one is required. The description adds no meaningful semantic value beyond the schema's bare field 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 retrieves full profile data in a single request, using 'everything included' to indicate comprehensive coverage. This distinguishes it from the many granular profile sibling tools (e.g., get_api_v1_profile_about, get_api_v1_profile_skills) that provide only specific sections.

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

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

Usage context is implied but not explicit. The phrase '1 request' suggests using this as a one-stop alternative to multiple calls, but the description does not explicitly say when to choose this over granular endpoints or mention any prerequisites. It is not misleading, but lacks clear 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?

No annotations are provided, so the description carries the full burden. It mentions billing per call (1 credit), which is a behavioral trait, but it doesn't disclose what the response contains, whether it's read-only, or any rate limits. The description is minimal and doesn't add much beyond the name.

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

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

The description is very concise (one sentence plus billing note). It's front-loaded with the core purpose. No wasted words, but it could be slightly more informative without losing conciseness.

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 output schema, no annotations, and a single parameter, the description should explain what 'complete work experience' includes (e.g., positions, dates, descriptions) and any limitations. It doesn't. The billing note is the only extra context. For a tool with such minimal structured metadata, this is insufficient.

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 1 parameter (urn) with 0% description coverage, but the description mentions 'by URN Group: Profile' which implies the urn parameter is a profile URN. The example in the schema provides a concrete format. The description adds minimal semantic value beyond the schema, but the schema itself is simple and self-explanatory.

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 retrieves complete work experience for a profile identified by URN, which is specific and distinguishes it from sibling tools like get_api_v1_profile_about or get_api_v1_profile_education. However, it doesn't explicitly contrast with the similar 'get_api_v1_profile_full' sibling, so it's not a perfect 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 provides no guidance on when to use this tool versus alternatives. It doesn't mention that it's for full experience data specifically, nor does it exclude other profile-related tools. The billing note is useful but not usage 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 only behavioral trait disclosed is the cost ('Billing per call: 1 Credits'). No other behaviors are mentioned, such as authentication requirements, read-only nature, rate limits, or side effects. With no annotations, the description carries the burden but falls short.

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, consisting of one clear sentence plus a billing note. It avoids unnecessary details and is well-structured, making it 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 description does not explain what the response contains beyond 'Interests', lacking details about format, structure, or possible errors. Since there is no output schema, this omission leaves the tool's expected return ambiguous, reducing its overall completeness.

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

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

The single parameter 'urn' is clearly described in both the schema and the description as 'profile URN'. The schema provides full coverage with an example and type. The description reinforces its purpose, leaving no ambiguity.

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 the tool fetches interests for a given profile identified by URN. It uses a specific verb ('Get') and resource ('Interests') and distinguishes itself from other sibling tools that handle different entities (e.g., articles, companies, posts).

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 does not provide explicit guidance on when to use this tool versus alternatives. It only states what it does and includes a billing note, without mentioning use cases, prerequisites, or comparison to other profile-related 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?

No annotations are provided, so the description carries full burden. It merely states 'Get' without disclosing that this is a read-only operation, potential permissions, or any side effects or limitations. This is a significant transparency gap for a tool that interacts with user data.

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

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

The description is a single, succinct sentence with no redundant information. It is perfectly sized for a simple GET endpoint and follows a clear structure.

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

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

The description omits crucial context such as the return format, authentication requirements, rate limits, or any error conditions. Since no output schema is provided, the description should compensate, but it does not.

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 description mentions 'by username', clarifying the purpose of the 'username' parameter, which adds value beyond the schema's type and example. However, it does not elaborate on what 'basic' includes or whether the username is a handle, ID, or URN.

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 it retrieves basic profile information using a username. The verb 'Get' is explicit, and 'basic' hints at a summary-level response, which differentiates it from more detailed profile endpoints like 'details' or 'about'.

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 does not provide guidance on when to use this tool versus other profile-related sibling tools (e.g., get_details, get_about). It lacks explicit context for selecting this endpoint over alternatives.

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

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

No annotations are provided, so the description must carry the full behavioral disclosure burden. It does mention billing cost, but it does not disclose pagination behavior, cursor handling, response shape, authorization needs, rate limits, or whether 'all' reactions are truly returned in one call.

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: the first sentence identifies the action, and the second sentence adds cost information. There is no redundant repetition of the tool name or unnecessary 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 tool has no output schema, no annotations, and an undocumented cursor parameter, so the description is not sufficiently complete. The agent can understand the basic purpose but cannot determine result shape, pagination requirements, or other behavioral constraints.

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 description adds some meaning for 'urn' by saying it identifies the profile, but with 0% schema description coverage it completely ignores the 'cursor' parameter. This leaves a significant gap for an agent trying to invoke the tool correctly.

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

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

The description clearly states the action (get all reactions) and the target resource (a profile identified by URN), making a distinction from post/article/comment reaction tools. It is specific enough for an agent to know it retrieves Profile-level reactions, though it does not explicitly contrast it with 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?

There is no guidance on when to use this tool versus alternatives like post likes, article reactions, or company reactions. The description also does not explain cursor usage or how to handle pagination if multiple calls are needed.

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

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

No annotations are present, and the description does not disclose any behavioral traits such as read-only nature, authentication requirements, rate limits, or side effects. The simplicity of the function is implied by the word 'Get', but no explicit behavioral information is provided, leaving the burden on the description unfulfilled.

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

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

The description is very brief and to the point, lacking unnecessary fluff. However, it includes extraneous metadata like 'Billing per call: 1 Credits' which does not aid understanding of the function. The structure is a single sentence, which is concise but could be more informative without becoming verbose.

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 does not explain what the response will contain, how to interpret the recommendations, or any context about the profile. With no output schema provided, the description entirely fails to give users a complete picture of what to expect, making it inadequate for effective usage.

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 'urn' has no description in the schema or the main description. The description mentions 'By URN' but does not explain what a URN is or how to format it. This is a severe lack of semantic meaning for the parameter, and the description does not compensate for the low schema 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 states the tool retrieves both given and received recommendations for a profile, using the verb 'Get' and specifying the resource (profile). It distinguishes from other profile tools by focusing on recommendations, which no sibling tool covers.

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 explicit guidance on when to use this tool versus alternatives. It only states what it does, without mentioning conditions or exclusions. Since sibling tools cover distinct endpoints, the context is implicit but not clearly 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?

With no annotations provided, the description is solely responsible for disclosing behavior. It adds a billing note ('Billing per call: 1 Credits') which is useful, but it omits other relevant context such as authentication requirements, read-only nature, pagination, or error cases, leaving the agent underinformed.

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 with the core action and an appended billing note. It is concise and avoids unnecessary verbosity, earning full marks for efficiency.

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?

Even for a simple read endpoint, the description leaves ambiguity about what 'profile services' entails and how it differs from service detail endpoints. There is no mention of response structure, potential errors, or usage context, making it incomplete for an agent to use confidently.

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 describes one parameter 'urn' with no description and zero required fields. The description's 'by URN' minimally flags this parameter's purpose, but with 0% schema coverage, more compensation is needed—such as format, source of URN, or constraints—which is 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?

The description 'Get profile services by URN' provides a clear verb and resource, and it clarifies the lookup key. However, it does not explicitly distinguish itself from sibling tools like get_api_v1_services_service_details or other profile sub-endpoints, so it stops short of full 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?

No usage guidance is provided—no indication of when to use this tool versus search_services or other profile endpoints, no mention of alternatives, exclusions, or intended scenarios. It simply states the primary action.

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

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

No annotations are provided, so the description must carry the behavioral burden. It communicates billing cost ('Billing per call: 1 Credits') and the read-only nature of 'Get', but it does not disclose return format, pagination behavior, or any rate limiting. This is adequate for a simple look-up but leaves gaps.

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 and every part earns its place: the action, the group, and the billing cost. There is no fluff or redundant repetition of the tool name.

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

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

For a one-parameter, no-output-schema tool, the description covers what it does and the billing cost. However, it does not describe what the returned 'similar profiles' look like (e.g., profile URNs, full profile objects) or any limitations, so completeness is adequate but not thorough.

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 is only one parameter, urn, and the schema description coverage is 0%. The description compensates by explaining that the URN belongs to the profile whose similar profiles should be fetched. The schema provides an example, and together they make the parameter's meaning clear.

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

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

The description uses a specific verb and resource: 'Get similar profiles for a given profile using its URN.' It clearly describes the input and the action, and the Group: Profile line helps distinguish it from company/job/service similar 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 makes the core usage clear: call it when you need similar profiles for a given profile URN. However, it does not explicitly discuss when not to use it or mention alternatives among the many profile sub-tools, so some usage guidance is implied rather than stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only mentions billing per call, but omits read-only nature, rate limits, authentication requirements, or response shape. For a tool with no annotations, this is a significant gap.

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 immediately convey the core action and a key operational detail (cost). Every word adds value, no fluff 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 one-parameter getter with a self-explanatory name, the description is minimal yet adequate, but it omits usage context among the many sibling profile tools and does not clarify return format or skill scope. It meets the minimum viable standard but leaves clear 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?

With 0% schema description coverage, the description needed to compensate, but 'By URN' merely restates the parameter name and does not explain URN format, how to obtain it, or whether it is required despite being listed as optional in the schema. The example in the schema provides more concrete guidance than the description.

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 'Gets profile skills By URN', specifying the action, resource, and input method. It is distinct from other profile tools by focusing on skills, but it does not explicitly contrast with siblings like get_api_v1_profile_full or get_api_v1_profile_overview, which might also include skills.

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 guidance on when to use this tool versus alternatives, such as get_api_v1_profile_full or get_api_v1_profile_overview. The mention of 'Group: Profile' is too vague to serve as a usage criterion, and the billing note only adds cost information, not selection 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?

No annotations are provided, and the description fails to disclose any behavioral traits beyond billing. It doesn't state whether the tool makes a network request, handles errors, or what the output looks like. The billing note is useful but insufficient; the description does not contradict annotations (since none exist), but it leaves the agent with no expectations about side effects or data format.

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?

This is a single sentence that is redundant: 'Get social network metrics By username Group: Profile. Billing per call: 1 Credits.' The first part repeats the tool name, and the second is a billing note. It is short, but it fails to convey the essential structure. The 'Group: Profile' hint is slightly helpful, but it's not enough to warrant a higher score.

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 complexity of the tool (likely returning a nested structure of social network metrics) and the absence of an output schema, the description provides no behavioral context. The tool has a single parameter, but with no description, the schema lacks any parameter semantics or output schema, the description is incomplete. The tool's output is a simple but no guidance on the schema's coverage is 0%. The tool has a description that returns a social matrix with no parameters, but the coverage is low.

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%, and the description only mentions 'By username' without explaining the format, constraints, or what the username should be (e.g., LinkedIn profile ID, URL, or LinkedIn URN). The schema provides the parameter 'username' but the description doesn't clarify if the username is an ID or slug. The single parameter is described as 'social matrix' which is a metric, but the description lacks any semantic meaning. The description does not add value beyond the schema field, and the schema provides a valid example, but no param semantics are needed.

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

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

The description is minimal and just states the tool gets social matrix metrics by username. It conveys the verb "Get" plus the resource "social matrix". However, the description is unclear about what data the social matrix actually contains, making it hard to distinguish from other profile-related tools like get_api_v1_profile_overview or get_api_v1_profile_details.

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 the many sibling profile tools. It doesn't mention whether this is for LinkedIn profile data, social network metrics, or if it requires a username that is a valid LinkedIn profile. With 47 sibling tools, the absence of usage context leaves the agent guessing.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It mentions 'Billing per call: 1 Credits' but does not state whether the call is read-only (likely, but not explicit), what happens if the username is invalid or not found, or any response format details. The safety and error profile are not addressed beyond the billing note.

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, with a single sentence containing the core action and two additional pieces of metadata (group and billing). It is front-loaded with the essential purpose and adds no fluff. However, it lacks structured subsections, which is acceptable for a tool this simple.

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 (one parameter, no output schema), the description might suffice for basic invocation, but it omits critical context such as the return value (a URN string), error conditions, and relationship to other profile endpoints. For instance, it doesn't explain that this URN is often a required input for other profile tools. The description is incomplete for an agent that needs to compose workflows.

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 only says 'by username', which reiterates the parameter name without adding format, requiredness, or example-based guidance (though the schema provides an example). The description does not clarify if the username is a LinkedIn profile URL slug, email, or other form, leaving ambiguity for the agent.

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 'Get urn of profile by username' clearly states the action (Get) and the resource (urn of profile) with a specific lookup key (username). This distinguishes it from sibling profile tools like profile_about or profile_details, none of which mention URN retrieval. The verb-resource pairing 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 provides no guidance on when to use this tool versus alternatives. It does not mention that this is the intended method for converting a username to a URN for subsequent API calls, nor does it cite any exclusions or alternative tools (e.g., universal name to ID for companies). The agent must infer usage solely from the name.

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

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

No annotations are present, and the description does not disclose behavior such as output format, pagination, or any side effects. It only states billing cost, which is not behavioral transparency.

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 brief, which makes it concise but at the expense of informativeness. It is not overly verbose, but it lacks the necessary substance to be considered well-structured.

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 six optional parameters and no explanation of how they interact or what the search returns, the description is incomplete. It fails to provide enough context for a user to effectively invoke 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?

The schema provides terse descriptions like 'geos ID' and 'industries ID', but these are cryptic and do not explain the actual meaning or format. The description adds no further clarification, leaving parameters ambiguous.

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 searches companies, and the verb 'search' combined with the resource 'companies' distinguishes it from sibling tools like search_people, search_posts, etc.

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 mentions 'all filters available' but does not explain when to use this tool versus other search tools, nor does it provide context on typical use cases or parameter combinations.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only adds 'Billing per call: 1 Credits,' which is useful, but it fails to mention any other behavioral traits such as pagination behavior, rate limits, authentication requirements, or what the response contains. This is a significant gap for a search tool with many parameters.

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, comprising a single line with no superfluous text. It front-loads the core purpose and adds the billing cost, which is actionable. However, it lacks any structural breakdown or examples, but for what it contains, it is efficient and to the point.

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 complexity (12 parameters, no output schema, no annotations), this description is severely incomplete. It does not describe the return format, how filters combine, pagination, or any usage caveats. The agent has almost no context to correctly construct a request or interpret results, making this inadequate for a search tool of this depth.

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 description says 'all filters available' but does not clarify individual parameter semantics beyond the schema. Since schema coverage is only 58%, five parameters (start, title, keyword, lastName, firstName) are undocumented in both schema and description. The description adds minimal value by not compensating for the missing parameter details.

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 verb 'search' and the resource 'people', and it distinguishes itself from sibling search tools like search_companies, search_posts, and search_schools. The phrase 'all filters available' adds specificity, making it unambiguous that this is a comprehensive people search endpoint.

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 guidance on when to use this tool versus alternatives, no mentions of limitations, exclusions, or scenarios where a different search tool would be more appropriate. The description merely says 'search people' with no context on typical use cases or edge cases, leaving the agent without direction.

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

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

No annotations are provided, so the description must carry the behavioral burden. It only adds a billing note and the fact that all filters are available. It does not disclose result types, pagination/offset behavior, default sorting, error cases, or any operational constraints.

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

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

The description is short and front-loaded with the core purpose: 'search Posts (all filters available)'. The 'Group' and 'Billing' details are concise and useful metadata. There is no fluff, though it sacrifices helpful detail for brevity.

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 12-parameter search endpoint with no output schema and no annotations, the description is incomplete. It does not explain pagination via 'start', expected response structure, default sort behavior, or any operational caveats. The schema covers parameters, but the description lacks broader operational 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 83%, and the schema already documents parameter meanings with examples, so the description does not need to repeat them. The description adds little beyond the general notion of 'all filters' but does not need to compensate given rich schema 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 states the tool 'searches Posts,' identifying the specific verb/resource. It distinguishes from similar search endpoints for companies/people/schools/services. The phrase '(all filters available)' is vague but the action and resource are 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?

There is no guidance on when to use this tool versus alternatives like get_api_v1_posts_all or other search endpoints. The description implies usage through 'search Posts' but provides no context, exclusions, or comparative instructions.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It only states 'search schools' and billing but doesn't indicate whether it's read-only, pagination behavior, rate limits, or what the response contains. It also doesn't explain what 'all filters available' means operationally. This is a significant gap for a tool with zero 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 very short (two sentences), which is concise, but it doesn't front-load critical information. It merges purpose with billing and group info, and the structure is not well-organized. It's not verbose, but it's under-specified, so it doesn't fully earn its place. It's acceptable in length but lacks substance.

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 (2 params, no output schema, no annotations), the description is severely incomplete. It fails to explain the parameters, the response format, any behavioral aspects, or even what 'schools' means in this context. A minimal search tool should at least describe the parameters and typical output. The description is far from sufficient.

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 doesn't explain the 'start' and 'keyword' parameters at all. The phrase 'all filters available' is vague and doesn't map to the actual parameters. The description adds no semantic meaning beyond the schema's example 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 clearly states the action (search) and resource (schools), distinguishing it from sibling search tools for people, companies, posts, and services. The title 'Schools' is vague, but the 'search schools' phrase provides a specific verb+resource. However, it doesn't specify the scope or any limitations, so it's not 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 guidance is given on when to use this tool versus alternatives. It doesn't mention any prerequisites, exclusions, or comparisons with other search tools. The 'Group: Search' and billing info are metadata but not usage directives. The only context is the resource type, which implies use for school searches.

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

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

With no annotations provided, the description carries the full disclosure burden. It discloses billing cost ('Billing per call: 1 Credits'), which is genuinely useful operational context for agents planning multi-call workflows. However, it's silent on rate limits, default behavior with no arguments, output expectations, and error semantics — a moderate gap for a search endpoint.

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 tightly written at under 20 words with the core purpose front-loaded. Every phrase earns its place, though 'Biling' is a typo and the metadata-style format ('Group:', 'Billing per call:') reads like auto-generated docs rather than intentional structure.

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

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

For a tool with 5 parameters, no annotations, and no output schema, this description is inadequate. It fails to explain result semantics, pagination, ordering, or how this search differs from the four other search_* siblings. An agent must guess at filter behavior and expected results, which is a significant gap for a search tool that could benefit from richer 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 coverage is only 40%, so the description should compensate for the undocumented params (start, geoUrn, keyword). The phrase 'all filters available' weakly signals that parameters are optional (consistent with 0 required params), but it adds no guidance on formats, combinations, or which params to prefer. This is below the baseline 3 for low schema 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?

'search services' is a clear verb+object statement of the tool's core function, and '(all filters available)' clarifies that filtering is optional, which is a useful scope signal. However, it doesn't distinguish itself from sibling search tools (search_people, search_companies, search_posts) beyond the 'services' subject, and the description largely restates the tool name.

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 only contextual marker is 'Group: Search', which is an implicit category label rather than actionable guidance. There's no mention of when to prefer this over sibling tools like search_people or search_companies, and no exclusions or workflow context provided.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It only mentions billing per call, which is a minor cost detail. It does not disclose read-only status, error behavior, rate limits, or any other operational characteristics.

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—one sentence plus a billing note. It is front-loaded with the core purpose and contains no filler or redundant 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 tool has one parameter, no output schema, and no annotations, the description is too sparse. It omits details about return value, error handling, prerequisites, or any other context needed for reliable 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%, but the description does clarify that the 'vanityname' parameter is the lookup key. However, it does not explain the parameter's format, requiredness, or constraints, leaving significant gaps beyond what the schema 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 clearly states the tool gets a service by VanityName, which is a specific verb+resource. However, it does not explicitly differentiate from sibling tools like get_api_v1_services_service_similar, so it falls 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 provides no guidance on when to use this tool versus alternatives. It mentions 'Group: services' and billing, but these are not usage guidelines. No exclusions or alternative tool references are provided.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It mentions billing ('1 Credits per call'), which is a useful cost disclosure, but does not specify whether the operation is read-only, what the return format is, or any other behavioral traits such as pagination or rate limits. This is insufficient for a tool with zero 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 sentence plus a billing note, with no superfluous words. The key action and cost are front-loaded, making it easy to parse quickly. It is an excellent model of conciseness.

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 one parameter and no output schema, the description is incomplete. It does not explain what the response contains (e.g., a list of similar services), any required preconditions like providing a valid vanityname, or possible error cases. The agent has to rely on the tool's name and example, which is insufficient for confident 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?

The schema has a single parameter 'vanityname' with an example but no description, and schema coverage is 0%. The description references 'VanityName Group' but does not explain what a vanity name is or how it should be formatted, leaving the agent to guess. The description adds minimal value beyond the parameter name itself.

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 'Get similar services by VanityName Group', indicating the verb (Get), resource (services), and the grouping key (VanityName). It differentiates from sibling tools like get_api_v1_services_service_details (which gets details) and get_api_v1_profile_similar (similar for profiles), but does not explicitly explain what 'similar' means or how it is determined, so it's clear but not fully distinct.

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 lacks any guidance on when to use this tool versus alternatives such as get_api_v1_search_services or other similar tools for different entities. It only states the function without indicating prerequisites, context, or when not to use it, leaving the agent to infer usage from the tiny description.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It only mentions 'Group: system' and 'Billing per call: 1 Credits', but gives no details about what the response contains, whether it requires authentication, or any side effects. This is insufficient for a mutation-free status check; agents need to know if it returns a simple health indicator or detailed metrics.

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, consisting of one short sentence plus metadata. No fluff or redundancy. The structure is front-loaded with the core purpose, followed by billing info. It earns a perfect score for efficiency.

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 zero-parameter status check tool, the description is almost sufficient. It reveals the tool's purpose and even mentions billing cost. Without an output schema, it could name the response format (e.g., JSON with state, uptime), but for a system status endpoint, the description is adequate. A score of 4 reflects that it covers the essentials, though a bit more detail on what 'status' includes would be nice.

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 to describe, so the description has no obligation to explain input semantics. The schema is empty, so no additional info is needed. Baseline 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 states 'status of LinkdAPI service' which clearly indicates this tool provides the API's operational status. It distinguishes itself from sibling tools that are all data retrieval endpoints by focusing on service health rather than domain data. However, it lacks a strong verb like 'check' or 'retrieve', making it slightly less explicit.

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 guidance is provided on when to use this tool versus alternatives. It doesn't mention that it's for health checks, pre-requisites, or that it should be called before other API operations. The description offers no exclusions or alternatives, leaving the agent to infer usage.

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