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

No annotations are provided, so the description carries the full behavioral burden. It discloses that the tool both reads and mutates the answer bank, but says nothing about permissions, reversibility, whether 'set' overwrites or merges, or what a read returns. For a mutation-capable tool with zero annotation coverage 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?

Two sentences, front-loaded with the verb+resource and a brief rationale. No filler, though the second sentence is more persuasion than 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?

A 4-parameter mutation tool with no annotations, no output schema, and an action enum with four undocumented modes. The description leaves the agent unable to determine how to invoke set-profile vs set-resume vs set, or what read returns, which is inadequate for this complexity.

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

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

Schema description coverage is only 25% (solely the 'entries' param is annotated), so the description must compensate but does not. It never explains the action enum values, nor the label/value pairing convention, nor how 'set-profile'/'set-resume' differ from plain 'set'. The content examples hint at possible labels but do not map to parameters.

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

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

The description states a specific verb pair ('Consulta o edita') and a concrete resource ('banco de respuestas que se reutiliza al postular'), then enumerates example contents (contact data, experience, availability, default CV). An agent can tell it apart from sibling tools like linkedin_job_apply or linkedin_profile_edit, but the description does not name any siblings explicitly.

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 when-to-use guidance or any statement about which action to pick (read vs set vs set-profile vs set-resume). The closing sentence ('Cuanto más completo, menos se atascan las postulaciones') is motivational advice, not routing guidance. Usage is only implied by the relationship to applying.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that the data is stored locally and includes application status and responses, but says nothing about ordering, freshness, read-only nature, or whether a session is required.

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

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

A single tight sentence with the resource front-loaded and no filler. Nothing extraneous, though it is arguably too sparse for the information an agent needs.

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

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

For a one-parameter read tool with no output schema and no annotations, the description at least identifies the payload contents (status and responses). It is still incomplete regarding the limit parameter and result ordering.

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% for the single 'limit' parameter, and the description never mentions it, its bounds, or how the result set is capped or ordered. The description 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?

States a specific resource and scope: a local history of applications made by this tool, including status and responses. It is reasonably distinguishable from siblings like linkedin_my_jobs, though it does not explicitly contrast itself with 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?

There is no statement of when to reach for this tool rather than linkedin_my_jobs, linkedin_job_apply, or linkedin_usage. Usage must be inferred entirely from the noun 'historial'.

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 behavioral burden, yet it only says what a click is. It does not disclose side effects (navigation, form submission, new page load), permission requirements, or what happens on failure, which matters for an action that mutates page state.

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

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

A single sentence with zero filler that front-loads the action and then the two targeting modes. Nothing could be removed without losing information.

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

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

With no annotations, no output schema, and no parameter documentation, the description is thin for an interactive browser action. An agent gets no information about the result of the click, whether it waits for navigation, or how to obtain a valid ref, leaving a significant gap.

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

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

Schema description coverage is 0%, so the description must compensate, and it does partially by explaining that ref comes from a prior snapshot and that text is the element's visible text. However, it leaves ambiguity about whether the two parameters are mutually exclusive, which takes precedence if both are supplied, and why both are optional.

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 (click) and resource (element), and specifies the two ways to identify the target. It implicitly links to linkedin_browser_snapshot by requiring a ref from a previous snapshot, which helps distinguish it from the other browser_* siblings, but it does not name any sibling explicitly.

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

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

Usage is only implied: the parenthetical '(de un snapshot previo)' hints that a snapshot must be taken first, which is a useful prerequisite. However, there is no explicit guidance on when to click by ref vs. by visible text, and no mention of alternatives such as linkedin_browser_type or linkedin_browser_navigate.

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 disclosure burden, yet it only says it returns a page 'radiografía'. It omits auth/session requirements, whether navigation triggers a browser launch, how redirects or rate limits are handled, and what the returned snapshot actually contains.

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

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

A single compact sentence that front-loads the action and result with no wasted words. Its brevity is a virtue here, though only because so little is stated.

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 navigation tool with no annotations, no output schema, and no parameter documentation, the description is too thin. An agent cannot know it needs an authenticated session or what the returned 'radiografía' comprises before calling 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 single 'url' parameter is undocumented in the schema (0% coverage). The description adds the constraint that the URL must be LinkedIn, but given the tool name already implies LinkedIn, this is marginal and no format or example is given.

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?

States a specific verb ('Navega') and resource ('una URL de LinkedIn') plus a return value ('la radiografía de la página'). An agent can tell it navigates a browser, though it does not contrast itself with the closely related 'linkedin_browser_snapshot', which also returns page 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?

No guidance on when to use this versus alternatives such as linkedin_browser_snapshot, linkedin_browser_click, or the profile/login tools. No prerequisites (an active logged-in session) are mentioned, leaving the agent to infer 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, so the description carries the full burden. It does disclose that the result is a file path, which is useful, but says nothing about output format, where the file is stored, or session/auth requirements for a browser operation.

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

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

A single efficient sentence with the key action and return value front-loaded. No filler, though it is arguably under-specified rather than merely 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?

For a simple one-parameter screenshot tool this covers the core behavior, but the undocumented 'name' parameter and the unresolved overlap with linkedin_browser_snapshot leave gaps an agent would likely hit in practice.

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 one optional 'name' parameter at 0% schema description coverage, and the description never mentions it. The agent gets no idea whether 'name' names the file, a target element, or something else, so the description fails to compensate for the coverage gap.

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

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

The description states a specific verb and resource – it captures the current screen and returns the file path – which is clear. However, it never differentiates itself from the sibling linkedin_browser_snapshot, so an agent cannot tell the two apart from the text alone.

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 when-to-use guidance, no prerequisite (e.g. an open browser session), and no mention of the near-identical linkedin_browser_snapshot sibling. The agent must infer the appropriate context entirely.

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 behavioral burden. It does disclose the lazy-loading motivation, but says nothing about how far scrolling proceeds, whether it mutates page state, or whether it blocks/returns after content loads.

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

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

One short, front-loaded sentence with no waste or redundancy. Its brevity is a strength structurally, though it sits at the edge of under-specification.

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

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

With no annotations, no output schema, and an undocumented parameter, the definition leaves an agent unable to call the tool precisely. For a simple browser pagination action, a sentence on step behavior and return timing would have closed the gap.

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

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

The single parameter "steps" has 0% schema description coverage and is never mentioned in the description, so its meaning, default, and the 1-20 bound are entirely undisclosed. With low coverage the description was required to compensate and 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?

"Desplaza la página" names a concrete verb+resource and adds a purpose clause ("para cargar contenido diferido"), so the basic action is clear. However, it offers no differentiation from siblings like linkedin_browser_snapshot or linkedin_browser_click, and it is written in Spanish while the rest of the tool set is English.

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 scroll versus taking a snapshot or navigating, nor any mention of prerequisites such as an open session. The only implied usage is the lazy-load rationale, which is not enough to route an agent among the many browser siblings.

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

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

With no annotations, the description carries the full disclosure burden. It conveys the fallback role and the returned content (actionable references), and implies a read operation, but omits whether login/session is required, any rate limits, and side-effect profile. Adequate context, but incomplete for an annotation-free 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?

Two tight sentences: the first front-loads what the output is, the second routes usage. No filler or redundancy, though the structure is minimal rather than notably well-organized.

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?

There is no output schema, so the description must describe returns; it does so at a high level (links, buttons, fields with references). It leaves the undocumented textLimit parameter and any session prerequisites unaddressed, so an agent still has gaps before invoking it 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 description never mentions either parameter. With only 50% schema coverage, textLimit is undocumented in both the schema and the description, and scopeSelector's purpose is left entirely to the schema. The prose adds no semantic value for the parameters.

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

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

States a specific action and output: a snapshot of the current page containing links, buttons and fields with references to click or fill. This clearly differentiates it from the visual linkedin_browser_screenshot and the higher-level action tools. It stops short of naming an explicit sibling, but the resource and return content 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?

Explicitly positions itself as 'la salida de emergencia' (the fallback) when a high-level tool fails to find something, giving a clear when-to-use condition. It does not state an explicit when-not or name the specific high-level alternatives it complements, so it falls short of a 5.

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

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

With no annotations, the description carries the full behavioral burden but discloses almost nothing: it does not explain that `ref` comes from a prior snapshot, whether the field must be focused first, or what the `submit` flag triggers (e.g. form submission/navigation). Only the bare mutation intent is implied.

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

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

A single short sentence with no wasted words, but it is under-specified rather than genuinely concise. Size is appropriate; 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 3-parameter browser-automation primitive with zero annotation coverage, no output schema, and no schema descriptions, the definition is incomplete. An agent lacks the context needed to reliably obtain a `ref` or predict the effect of `submit`.

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% across three parameters, and the description only alludes to `ref`. The `text` parameter and especially the optional `submit` boolean (whose default and side effects are unknown) receive no semantic explanation anywhere.

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 Spanish description states a verb and a target ('Escribe en un campo') tied to the `ref` parameter, so the core action is inferable. However, it gives no scope or differentiation from the many sibling browser tools (click, snapshot, navigate), leaving the agent to guess when typing is the right primitive.

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 `linkedin_browser_click`, `linkedin_browser_navigate`, or `linkedin_browser_snapshot`. No prerequisites, no mention of needing a prior snapshot to obtain a valid `ref`, and no 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?

With no annotations, the description carries the full burden. It usefully discloses that the session persists on disk and will be reopened by the next tool, which is the most important behavioral fact for this tool. However, it says nothing about what is lost when the browser closes (open page state, in-flight operations) or whether the call blocks.

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

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

Two short sentences with zero waste, leading with the action and immediately following with the consequence that matters most to the caller. Every clause earns its place.

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

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

For a zero-parameter lifecycle tool with no output schema, the description covers the essential concern (session durability across close/reopen). It could add a sentence on what browser state is discarded, but nothing needed to invoke it correctly is absent.

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

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

The tool takes zero parameters, which is the baseline-4 case; there is nothing for the description to clarify beyond the schema's empty object. No parameter detail is required or missing.

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 gives a specific verb+resource ('Cierra el navegador' / close the browser), which is clearly distinct from navigation, snapshot, or session-status siblings. It does not explicitly name any sibling, so it falls short of full differentiation, but the action 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?

Usage is implied rather than stated: an agent can infer this is the teardown step at the end of a browser workflow, and the note that the next tool reopens the browser hints at ordering. There is no explicit when-to-use, when-not-to-use, or named alternative.

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

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

With no annotations present, the description carries the full burden, and it usefully discloses that the action is visible to the recipient and that confirm=true is mandatory. It stops short of covering rate limits, what happens if the invitation is already pending, or the result of the 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?

Two compact sentences with the core action first, then the note constraint, then the visibility/confirmation caveat. No filler, nothing repeated unnecessarily.

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 3-parameter mutation tool with no annotations and no output schema, the description covers the essential prerequisites (confirm=true) and side-effect visibility. It omits failure modes and post-send state, leaving a moderate gap.

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

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

Schema description coverage is 67%; the schema already documents target (URL/public identifier) and confirm, and maxLength=300 already encodes the note limit that the description restates. The description adds only marginal meaning 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?

States a specific verb and resource ('Envía una invitación a conectar'), which is clearly distinguishable from siblings like linkedin_follow or linkedin_message. It does not, however, explicitly name those alternatives to sharpen the distinction.

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 send a connection invite versus using linkedin_follow, linkedin_message, or linkedin_invitations. The closest thing to a condition is the confirm=true prerequisite, which is a safety gate rather than 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?

With no annotations, the description carries the full burden, but it does disclose one substantive behavioral fact: the operation requires confirm=true. This matters because the schema's required list omits confirm, so the description reveals a de facto mandatory gate for a write action on someone else's profile. It still says nothing about permissions, whether endorsement is reversible, 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 short sentences with the purpose front-loaded and the hard requirement immediately after. No filler, though it is arguably too terse to be fully useful.

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 mutation tool with no annotations, no output schema, and 0% parameter coverage, the description is thin: an agent cannot infer the expected form of target or how to obtain valid skill strings. Only the confirm gate is covered.

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

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

Schema description coverage is 0% for 3 parameters. The description clarifies confirm (effectively required, contradicting the schema's required list) but leaves target (format? URL, vanity name, URN?) and skills (which skill names are valid, where they come from) completely unspecified, so it compensates for only one of three gaps.

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

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

"Valida aptitudes en el perfil de otra persona" gives a verb (valida) and a resource (aptitudes/perfil ajeno), and the scoping to another person's profile is useful. However, "validar" is a loose synonym for endorsing given the tool name linkedin_endorse, and nothing distinguishes it from siblings like linkedin_profile_read or linkedin_profile_sections that also touch profiles.

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 guidance is "Exige confirm=true," which is a precondition rather than when-to-use direction. There is no mention of when to endorse versus messaging, following, or reading a profile, and no 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. It does disclose one meaningful behavioral requirement — that confirm=true is mandatory before the action executes — which is a safety guard the schema does not explain. It omits side effects (does following notify the target?), reversibility, and any rate limits or auth requirements.

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

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

Two short sentences with no filler, and the confirm precondition is front-loaded so an agent cannot miss it. Nothing could be removed without losing 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?

This is a mutating social action with no annotations, no output schema, and an undocumented required parameter. The description says nothing about result behavior, errors when confirm is omitted, or whether the operation is idempotent, leaving real gaps for a write tool.

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

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

Schema coverage is only 33% and the required 'target' parameter has no description at all. The description partially compensates by clarifying follow's direction and the mandatory confirm flag, but it adds nothing about what form 'target' takes (vanity name, URL, URN) or its accepted syntax.

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

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

The description names a specific verb pair and resource: follow or unfollow a profile. That is unambiguous. It does not, however, distinguish itself from adjacent siblings like linkedin_connect or linkedin_endorse, which involve related social actions on profiles.

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 follow versus when to use linkedin_connect (connection request) or any other sibling, and no stated preconditions beyond the confirm flag. Usage must be inferred purely from the verb.

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. It reveals that accept/ignore/withdraw are mutations, but says nothing about whether they are irreversible, whether the 'confirm' flag gates them, whether authentication is required, or what the list actions return.

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

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

A single compact sentence that front-loads the resource and then the capabilities. No waste, though a second clause spelling out the confirm/personName requirements would have earned 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?

Three parameters, no annotations, and no output schema, yet the description explains neither the 'confirm' flag, nor the personName requirement for mutations, nor what the listing actions return. For a tool that mixes reads and destructive writes, this is under-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 coverage is only 33%: personName is documented in the schema itself, but the description adds no meaning for 'action' beyond restating the enum values in prose and says nothing about the undocumented 'confirm' boolean, whose required/optional role is left entirely opaque.

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?

States a specific resource (pending invitations) and enumerates the supported verbs (list received/sent, accept, ignore, withdraw), so the agent can distinguish it from linkedin_connect, which sends new invitations. It is clear but does not explicitly name a sibling it must not be confused with.

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

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

It implies the operational range by listing the five actions, but gives no guidance on when to pick this tool over linkedin_connect or linkedin_notifications, and no preconditions for the mutating actions. Nothing tells the agent when a given action is appropriate.

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 and does it well: it discloses that the default is a dry-run that walks the whole form and returns missing questions, that a real submission requires two flags, and that answers are persisted for future use. These are real side-effects and safety behaviors beyond what any structured field provides.

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

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

Front-loads the default safe behavior, then the condition to override, then the persistence side-effect, in a compact set of sentences with no filler.

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

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

For an 8-parameter, no-output-schema mutation tool, the description covers the safety default, the send condition, and answer persistence well. Minor gaps remain for maxSteps and resumePath behavior, but nothing essential to calling it correctly is missing.

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

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

Schema coverage is 75% but the description adds the crucial semantics: dryRun defaults to true and confirm is mandatory for a real send, plus that answers persist. It doesn't document maxSteps, resumePath, or rememberAnswers, so those rely on the schema alone, but the critical interaction between parameters is explained.

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

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

States a specific verb and resource ('Postula a una oferta con Solicitud sencilla' = apply to an offer via Easy Apply), which clearly distinguishes it from linkedin_job_save (saving) or linkedin_job_detail (reading). An agent can identify the action without opening the schema.

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

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

Explicitly states the default is a simulation that fills the form and stops before submitting, and gives the exact condition needed to actually send (dryRun=false AND confirm=true). It also notes new answers are reused in later applications, covering the when-to-use-and-what-to-expect.

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 behavioral burden. It does not state that this is a read-only operation, whether it requires an authenticated session, whether it navigates or mutates browser state, or whether it can fail for closed/expired postings.

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

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

A single front-loaded sentence with no filler; the returned-field list is directly useful given there is no output schema, though it is slightly long for the amount of actionable information conveyed.

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 read tool with an exhaustive schema and no output schema, the description usefully enumerates the returned payload, which partly compensates for the missing output schema. It is still incomplete on session/auth requirements, which matter in this browser-automation toolset.

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% — the single "job" parameter already documents that it accepts a numeric ID or URL. The description adds nothing about the parameter beyond what the schema states, so the baseline 3 applies.

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

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

States a specific verb ("Trae") and resource ("detalle completo de una oferta") and enumerates the returned fields (description, company, location, applicant count, Easy Apply flag), which distinguishes it from linkedin_jobs_search. It never names a sibling or exclusion explicitly, so differentiation is implicit rather than stated.

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

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

There is no when-to-use guidance: nothing says this should be called after linkedin_jobs_search to resolve a job ID, nor that linkedin_job_apply is the follow-up action. No prerequisites (e.g. an active logged-in session) are mentioned despite this being a browser-backed session tool.

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

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

No annotations exist, so the description carries the full behavioral burden. It does convey that the tool can both save and unsave, but it omits authentication requirements, whether the operation is idempotent, what happens on repeat calls, and how the target job is identified.

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

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

A single short sentence, front-loaded with the core action and free of filler. It is efficient, though it is so terse that brevity comes at the cost of the missing detail noted elsewhere.

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 mutation tool with no annotations, no output schema, and fully undocumented parameters, the description is too thin to let an agent call it correctly without guessing the `job` format and `save` semantics.

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 neither parameter is documented. The description hints that direction is controllable (save vs remove) but never explains what format the required `job` string takes (ID, URL, slug) or what the `save` boolean defaults to or does.

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 gives a clear verb pair ("Guarda o quita" = save or remove) and a specific resource (a job offer in the saved list), so an agent can tell it is not linkedin_job_apply or linkedin_my_jobs. It stops short of explicitly naming which sibling handles related operations, but the action 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?

There is no statement of when to use this versus linkedin_job_detail, linkedin_job_apply, or linkedin_my_jobs, and no preconditions (login state, valid job identifier). Usage can only be inferred from the single sentence.

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, and it does add one useful behavioral trait: results flag Easy Apply eligibility and already-applied status. But it says nothing about auth/session requirements, pagination, rate limits, or how the enrichment is surfaced.

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

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

Two tight sentences with the primary purpose front-loaded and the result-enrichment note second. No filler, though it is arguably too terse for a 10-parameter tool.

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

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

For a 10-parameter search with no annotations and no output schema, the description does not explain parameter meaning, return shape, or pagination. The mention of Easy Apply / applied flags is the only return detail provided.

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% across 10 parameters, and the description only alludes vaguely to 'los filtros de LinkedIn' without naming or explaining any of them. Only 'Solicitud sencilla' loosely maps to easyApplyOnly, leaving limit, start, sortBy, jobType, location, workplace, datePosted and experienceLevel entirely undocumented.

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

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

States a clear verb+resource ('Busca ofertas de empleo') and scopes it to LinkedIn filters, which distinguishes it from siblings like linkedin_job_detail or linkedin_my_jobs. However, it doesn't explicitly name which sibling to use instead for adjacent tasks, so it stops short of 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 when-to-use guidance, no prerequisites, and no routing to alternatives such as linkedin_job_detail (for a single posting) or linkedin_my_jobs. The agent must infer context from the name 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?

With no annotations, the description carries the full burden and does it well: it discloses the blocking wait for manual entry including 2FA/captcha, that the session is persisted to disk and reused, and the deliberate anti-automation rationale to avoid LinkedIn blocks. It omits what a login failure looks like or how completion is signaled.

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

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

Three focused sentences, front-loaded with the action, then persistence semantics, then the rationale. Every sentence contributes distinct information with no filler.

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

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

For a login tool with no output schema and no annotations, the definition covers the interaction model but is silent on return values and how success versus timeout/failure is reported to the agent. Adequate but with a clear gap.

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

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

Schema coverage is 100% and the single timeoutSeconds parameter is fully documented in the schema, so the description adds no parameter detail. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

States a specific action (opens a browser window at the login screen) and its defining scope (waits for manual user login). This clearly distinguishes it from siblings such as linkedin_session_status and linkedin_close_browser without needing their schemas.

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

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

Implies the tool is the entry point for establishing a session before other authenticated calls, and explains why login is intentionally manual. It never explicitly names an alternative or states when NOT to use it (e.g., 'skip if linkedin_session_status shows an active session').

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 behavioral burden. It usefully discloses the confirm=true requirement, which is non-obvious because the schema does not list confirm as required (only target and text are). However, it omits other important traits for an irreversible outbound action: auth prerequisites, rate limits, and consequences of omitting confirm.

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, front-loaded with the action and followed by the constraint. No wasted words, though it is arguably too sparse given the complexity of the operation.

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 an external, side-effecting message-send tool with no annotations, no output schema, and 0% parameter coverage, the description is too thin. It should specify the target format, auth requirement, irreversibility, and possibly rate limits to be callable with confidence.

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

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

Schema description coverage is 0%, so the description must compensate for all three parameters. It loosely covers target ("a un contacto") and the confirm requirement, but says nothing about the text parameter (the message body, up to 8000 chars) or the expected format of target (handle, URL, name?). The coverage gap is not filled.

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+resource ("Envía un mensaje directo a un contacto"), clearly distinguishing it from siblings like linkedin_connect (connection request) or linkedin_post_comment (public comment). It does not explicitly name any sibling it must not be confused with, but the purpose is unambiguous.

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

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

No guidance on when to use this tool versus alternatives such as linkedin_connect or linkedin_post_comment, and no preconditions beyond the confirm flag. The agent must infer usage context entirely.

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 and no output schema, so the description carries the full behavioral burden. It implies a read-only listing but says nothing about authentication requirements, result limits, pagination, or what fields are returned, and it does not disclose whether the saved/applied lists behave differently.

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

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

One sentence with no filler, and the resource being listed is front-loaded. It is appropriately sized for a one-parameter listing tool, though the parenthetical brand reference is decorative rather than 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?

For a simple read tool with one optional enum parameter and no output schema, the description is minimally adequate. It leaves gaps around login/session prerequisites and result shape that an agent would have to discover at call time.

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 'tab' parameter is only an enum, so the description must add meaning. It does translate the enum into natural language ('ofertas guardadas' = saved, 'solicitudes enviadas' = applied), but adds no default value, no behavior when omitted, and no other 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 pairs a specific verb ('Lista') with a specific resource ('tus ofertas guardadas o tus solicitudes enviadas') and anchors it to LinkedIn's 'Mis empleos' section. It is clear what the tool returns, though it never explicitly names how it differs from siblings like linkedin_jobs_search (open search) or linkedin_applications_log.

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

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

Usage is implied: this tool is for reviewing jobs you already saved or applied to, not for discovering new ones. However, there is no explicit when-to-use statement, no exclusion of the closely related linkedin_jobs_search / linkedin_applications_log, and no stated prerequisite such as an active session.

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 behavioral burden, and it discloses almost nothing: not whether reading requires authentication, whether results are paginated, whether 'recientes' implies a fixed window, or what the response contains. Only the vague implication of a read-only retrieval is conveyed.

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

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

One short, front-loaded sentence with no filler, which is well-sized for a simple read tool. The brevity here reflects under-specification rather than tight editing, so it cannot score 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?

With no annotations, no output schema, and an undocumented parameter, the description leaves too much unexplained for a tool in a dense 40-sibling surface. An agent has no basis for deciding between this and linkedin_invitations or linkedin_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 coverage is 0% and the single 'limit' parameter (1-50) is undocumented in both schema and description. The description never mentions the limit or its meaning, so an agent cannot tell whether omitting it applies a default or returns everything.

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 verb+resource ('Lee las notificaciones recientes') so the agent knows it retrieves notification data. However, it offers no differentiation from the many other read-oriented siblings (linkedin_posts_read, linkedin_invitations, linkedin_session_status), and the 'recientes' scope is never bounded.

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 when-to-use guidance, no prerequisites (e.g., that a logged-in session is required for LinkedIn), and no mention of alternatives or exclusions. The agent must infer entirely from the name that this is the tool for checking notifications.

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 says nothing about authentication/session prerequisites, rate limits, pagination behavior, or what results look like, offering only the connection-degree filter hint.

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

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

A single short sentence, front-loaded with the core action and no wasted words. It is efficient, though perhaps overly terse given the gaps elsewhere.

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

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

With no annotations, no output schema, and 0% parameter coverage, the description is too thin for a 4-parameter search tool. Pagination, result format, and auth requirements are all unspecified, leaving an agent without the context needed to call it well.

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

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

Schema coverage is 0%, so the description should compensate but only loosely gestures at two of four parameters ('palabras clave' for keywords, 'grado de contacto' for connectionDegree). It never explains page/limit pagination semantics or the enum values 1/2/3 for connectionDegree.

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?

States a specific verb and resource ('Busca personas') and names the primary input dimension ('por palabras clave'). The resource 'people' implicitly distinguishes it from linkedin_jobs_search, but there is no explicit sibling differentiation.

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

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

No guidance on when to use this tool versus alternatives (e.g., linkedin_jobs_search) or when not to. The connection-degree reference describes a capability, not a usage context, so the agent is left to infer applicability.

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

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

With no annotations provided, the description carries the full behavioral burden, yet it only adds the confirm=true gate. It does not disclose that this is a public, non-reversible write action, nor auth/permission needs, rate limits, or failure modes.

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 very short sentences, with the action stated first and the safety constraint second. Zero wasted words and well 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 mutation tool with no annotations, no output schema, and no parameter documentation, the description is far too thin. An agent lacks the when-to-use context and the semantics of the required text/postUrl parameters.

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

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

Schema description coverage is 0% and neither text nor postUrl meaning is explained. The description only clarifies that confirm must be true (schema lists it as optional), which is useful but leaves two required parameters undocumented.

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

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

States a specific verb and resource (comment on a post), which cleanly distinguishes it from siblings such as linkedin_post_react, linkedin_post_create, and linkedin_posts_read. However, it offers no explicit differentiation from those siblings in the text 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?

There is no guidance on when to use this tool versus alternatives like linkedin_post_react or linkedin_message, nor any exclusions or prerequisites beyond the bare confirm requirement. Usage must be inferred from the name 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?

With no annotations, the description carries the full behavioral burden, and it does disclose one meaningful trait: this is a write action gated behind an explicit confirm=true flag. It does not describe visibility defaults, permanence, rate limits, or what publishing returns. It also asserts confirm is mandatory while the schema's required list contains only "text", which is a latent inconsistency the caller must resolve.

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

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

Two short sentences with no filler, and the action is front-loaded ahead of the prerequisite. The brevity is efficient rather than padded, though it shades into under-specification rather than true economy.

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 an unannotated mutation tool with no output schema and 0% parameter coverage, the description should explain visibility behavior, image handling, and the confirmation contract. It covers only the action and the confirm gate, so an agent is left guessing about most of the call surface.

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% across 4 parameters, so the description must compensate and largely does not: text, imagePath, and the visibility enum (anyone/connections) are never explained. Only confirm is addressed, leaving most of the parameter surface undocumented in both places.

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?

"Publica en el feed" states a specific verb (publish) and a specific resource/location (the LinkedIn feed), so the agent knows exactly what the tool does. It does not differentiate from siblings such as linkedin_post_comment or linkedin_post_react, which also act on feed content, so it stops short of a 5.

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

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

It states a hard prerequisite ("Exige confirm=true"), which is a usage constraint the agent must satisfy before calling. However, it gives no guidance on when to prefer this tool over the adjacent post-interaction tools, so usage is only partially covered.

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 behavioral burden, and it discloses only that confirm=true is mandatory. It says nothing about the fact that reactions are public and visible to the post author, whether they can be undone, or the session/auth requirements implied by the many login/session siblings.

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

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

Two short sentences, with the core action stated first and the confirm requirement second; no filler. It is efficient, though the extreme brevity trades away information rather than compacting it.

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 mutation tool with no annotations, no output schema, and 0% schema description coverage, the description is too thin. An agent needs to know the postUrl format, the reaction default, and the public/irreversible nature of publishing a reaction, none of which is present.

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

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

Schema description coverage is 0%, so the description must explain the three parameters. It clarifies that confirm must be true but says nothing about the required postUrl format or which reaction value applies by default versus the enumerated options (like, celebrate, support, etc.), leaving two of three parameters undocumented.

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

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

States a specific verb and resource ('Reacciona a una publicación'), so the agent immediately knows this adds a reaction to a post. It is distinguishable in substance from siblings like linkedin_post_comment or linkedin_posts_read, but the description never names those siblings or explicitly contrasts itself with them, so differentiation is left to the agent.

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 usage instruction is 'Exige confirm=true', a prerequisite rather than guidance about when to choose this tool. There is no mention of when to react versus comment, create, or follow, nor any condition or exclusion to route the agent correctly.

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

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

With no annotations, the description carries the full behavioral burden, yet it only implies a read via 'Lee'. It says nothing about authentication/session requirements, rate limits, pagination, result ordering, or what happens when a profile identifier is invalid — all relevant for a scraper-style 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?

A single front-loaded sentence with no filler. It is efficient, though the extreme brevity edges toward under-specification rather than genuine 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 2-parameter tool with no annotations and no output schema, the description should explain return shape, pagination, and the meaning of 'limit', but it does none of these. It leaves core operational questions unanswered.

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 50%: 'source' is documented in the schema, but 'limit' (1-50) is undocumented everywhere, and the description repeats the feed/profile distinction already present in the schema. It fails to compensate for the coverage gap by explaining what 'limit' bounds.

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?

States a specific verb ('Lee') and resource ('publicaciones') and clarifies the two scopes it covers: the feed or a profile's recent activity. This is clear and interpretable, but it never distinguishes itself from nearby siblings like linkedin_profile_read or linkedin_profile_sections, so an agent must infer the boundary.

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

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

It names the two data sources (feed vs profile activity) but gives no when-to-use guidance, no prerequisites, and no routing against alternatives such as linkedin_profile_read or linkedin_browser_snapshot. The agent is left to guess which reading tool to pick.

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

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

With no annotations, the description carries the full behavioral burden, yet it only says the About section is rewritten. It does not disclose that a write only happens conditionally via a separate 'save' flag, whether publishing is live/irreversible, what happens to existing About content, or any auth/rate-limit requirements.

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?

It is a single front-loaded sentence with zero filler, which is structurally clean. However, the extreme brevity comes at the cost of substance rather than from efficient packing of information.

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

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

For a profile-mutating tool with no annotations, no output schema, and 0% parameter coverage, the description leaves critical gaps: the effect on live profile data, the role of the 'save' flag, and the content length limit. It is not adequate for an agent to call this tool safely.

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

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

Schema description coverage is 0%, so the schema documents neither parameter. The description likewise says nothing about 'text' (the new content, max 2600 chars) or 'save' (whether changes are persisted), leaving the most consequential parameter, the save toggle, completely unexplained.

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

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

The description names a specific verb ('Reescribe') and a specific resource (the 'Acerca de'/About section), which lets an agent distinguish it from headline, image, or custom-URL siblings. It is clear but does not differentiate itself from a general sibling like linkedin_profile_edit, and it doesn't clarify whether 'rewrite' means generate-and-replace or merely update stored text.

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

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

There is no statement of when to use this tool versus linkedin_profile_edit or linkedin_profile_read, and no prerequisites (login/session state) are mentioned. The single sentence implies an editing action but gives the agent nothing to route on.

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 behavioral burden, and it discloses almost nothing. For a mutation of an account-visible identifier, it omits whether the change is reversible, whether LinkedIn imposes change limits, whether the old URL stops resolving, and what error occurs if the slug is taken.

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

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

A single front-loaded sentence that identifies the action and the target field with zero filler. It is efficient, though the brevity comes at the cost of the missing behavioral detail noted elsewhere.

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

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

With no annotations, no output schema, and an undocumented parameter, the description is the only source of context and it supplies just one sentence. For a profile-mutating tool it should at minimum cover the session prerequisite and the consequence/irreversibility of changing the public profile URL.

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 parameter 'vanity' carries no schema documentation, but the description's example '(linkedin.com/in/loquesea)' clarifies that the value is the slug portion rather than a full URL, which is genuinely useful disambiguation. It still adds no guidance on allowed characters or the 3-100 length bounds.

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 verb 'Cambia' plus the resource 'URL personalizada del perfil' is specific, and the parenthetical example (linkedin.com/in/loquesea) pins down exactly which profile field is affected. It is distinguishable from sibling tools like linkedin_profile_edit or linkedin_profile_headline, though it never explicitly contrasts itself with 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 states only what the tool does, with no when-to-use guidance, no mention of adjacent tools (e.g. linkedin_profile_edit), and no prerequisites such as needing an active session. The agent must infer that this is the tool for the vanity-slug field specifically.

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 full behavioral burden, and it contributes one genuinely useful trait: save=false leaves the form open and filled for review, plus partial label matching. It omits other important mutation behavior such as auth requirements, whether save=true overwrites existing content, or failure handling.

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

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

Three short sentences, front-loaded with the purpose, followed by the label-matching rule and the save recommendation. Every sentence adds distinct information with no filler.

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

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

For a mutation tool with a nested object and no output schema, the description explains the fill-vs-save model but omits what happens after a successful save (navigation, confirmation, errors). The rich schema compensates partially, but the behavioral picture is not fully closed.

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%, so the baseline is 3, but the description adds meaning beyond the schema: keys of the values object resolve by visible label and support partial matching, and the save=false behavior is spelled out as a review flow. This is useful semantics not captured in the field descriptions 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?

States a specific verb+resource: 'Rellena una sección del perfil y opcionalmente la guarda', which clearly conveys a profile-section write. It does not, however, differentiate itself from overlapping siblings like linkedin_profile_headline or linkedin_profile_about, so the agent cannot tell when to prefer this generic editor.

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?

Gives a concrete recommended workflow: 'Con save=false ... es lo recomendado la primera vez', which tells the agent how to sequence a first invocation safely. It does not, however, address when to use this tool versus the dedicated sibling editors, so the selection guidance is incomplete.

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 behavioral burden, yet it only implies a mutation. It does not disclose whether the change is applied immediately, what the 'save' flag does, permission/auth requirements, or reversibility. For an unannotated write tool 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?

A single front-loaded sentence with zero filler, efficiently conveying the action and the target field. Its only weakness is that brevity here reflects under-specification rather than tight editing.

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 an unannotated mutation tool with no output schema and 0% parameter coverage, the description is too thin. It omits the meaning of 'save', validation constraints, and any environment/auth context needed to invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate and largely does not. It clarifies what the headline field means but says nothing about the 'save' boolean or the 220-character limit, leaving one of two parameters effectively unexplained.

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?

States a specific verb (Cambia/cambiar) and resource (el titular del perfil), and even clarifies what the headline is (the line under the name). It is clearly distinguishable from siblings like profile_about or profile_edit, though it never names or contrasts them explicitly.

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 when-to-use guidance, no prerequisites (e.g., must be logged in), and no mention of alternatives such as linkedin_profile_edit or linkedin_profile_about. The agent is left to infer everything about when this is the right tool.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says an upload occurs but not that an existing photo is overwritten, that authentication/session is required, what image formats/sizes are accepted, or whether the operation is reversible — all significant gaps for a mutation 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?

A single, front-loaded sentence with zero filler. It is efficient, though arguably under-specified rather than optimally concise for a mutation tool.

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

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

For a write operation with no annotations, no output schema, and only 50% schema coverage, the description omits authentication requirements, overwrite behavior, and accepted file types. An agent cannot reliably call this without external assumptions.

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%: filePath is documented but the kind enum is not. The description's "foto de perfil o imagen de portada" does clarify the two enum meanings, adding real value, but it gives no format or path syntax detail 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?

States a specific verb ("Sube") and resource ("foto de perfil o imagen de portada"), which maps directly onto the two enum values. It is clear what the tool does, though it offers no differentiation from siblings like linkedin_profile_edit, which could also touch profile imagery.

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 versus linkedin_profile_edit or other profile-mutating siblings, no statement of prerequisites (an active session/login), and no conditions or exclusions. The agent must infer usage entirely.

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, and it discloses the key behavioral trait: the editor is opened but nothing is saved, plus the exact shape of the returned data (label, type, required, options). It omits auth/session prerequisites and failure behavior, but the safety-relevant disclosure is solid.

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

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

Two sentences, no filler, with the action and the no-save constraint front-loaded before the usage instruction. Every clause earns its place.

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

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

There is no output schema, so the description compensates by enumerating the returned fields, and it explains why field inspection matters (matching LinkedIn's current field names). Nothing essential for correct invocation is missing.

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

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

Schema description coverage is 100% and the only parameter (section) is documented with its allowed values, so the schema does the work. The description adds no extra meaning about the parameter itself, making the baseline 3 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?

States a specific verb and resource (opens the section editor and returns the exact current fields), and the 'sin guardar nada' clause distinguishes it functionally from the write siblings such as linkedin_profile_edit. An agent can tell what it does without opening the schema.

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?

Gives an explicit when-to-use rule ('Úsalo antes de editar una sección por primera vez'), which is actionable. It does not name an alternative tool or state when not to use it, so it stops short of the top mark.

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 behavioral burden. 'Configura' implies a mutation, but the description says nothing about auth/session requirements, reversibility, what existing settings are affected, or what the 'save' flag does (preview vs persist) — a significant gap for a write 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?

A single, efficient sentence with the resource and its fields front-loaded and no wasted words. It is appropriately sized, though it is arguably too terse given the tool's mutation semantics.

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 mutation tool with no annotations, no output schema, a nested object parameter, and an undocumented 'save' flag, the description is insufficient. An agent cannot confidently determine how the write persists or what the nested values must contain.

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%: the 'values' object has an example, but 'save' is undocumented in both schema and description. The description does enumerate the field keys the 'values' object expects, adding some meaning beyond the schema example, but leaves the save/persist control entirely unexplained.

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 ('Configura') and resource ('Abierto a trabajar') and enumerates the configurable fields (cargos, ubicaciones, tipos de empleo, quién puede verlo). It is clearly distinguishable from siblings like linkedin_profile_headline or linkedin_profile_about, though it does not explicitly name those alternatives.

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 other profile-editing siblings, nor any stated prerequisites such as an active session or login. Usage is only implied by the resource 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 provided, so the description carries the full behavioral burden. It discloses that this is a read operation and lists the exact fields returned, which is meaningful. It does not mention session/auth prerequisites, rate limits, or whether a public identifier requires a logged-in session, leaving real 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?

A single, front-loaded sentence that leads with the action and resource before enumerating the returned sections. Efficient with no filler, though the field enumeration makes it slightly dense.

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 only one optional parameter, no annotations, and no output schema, the description compensates well by enumerating the returned sections, effectively serving as return-value documentation. It lacks only negative guidance (when not to use it) to be 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 100%, so the single 'target' parameter and its 'me'/URL formats are already documented in the schema. The description adds the useful default ('el propio por defecto'), but otherwise does not extend parameter meaning beyond the schema, making the baseline 3 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?

States a specific verb ('Lee') and resource ('perfil completo') and enumerates the sections returned (titular, acerca de, experiencia, educación, etc.), so an agent can tell it is a full-profile reader rather than a single-section reader. It does not explicitly name the sibling it differs from (e.g., linkedin_profile_sections), 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 parenthetical 'el propio por defecto' tells the agent the default target is the authenticated user's own profile, which is useful invocation context. However, there is no explicit when-to-use-vs-alternatives guidance, e.g., when to call this versus linkedin_profile_sections or the narrower linkedin_profile_headline/about 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 disclosure burden. It conveys the returned content (editable sections and their typical fields) and implies a read-only enumeration, but says nothing about login/session requirements, whether it reflects live profile state, or rate/latency 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?

A single compact sentence with zero filler and the core purpose front-loaded. It is appropriately sized for a zero-parameter discovery tool, though it could be marginally more explicit about scope.

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

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

With no output schema and no annotations, the description is the sole source of return-value information, and it only roughly sketches the shape ('sections...with usual fields'). It is adequate for a simple enumerator but leaves the exact output structure and any prerequisites underspecified.

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

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

The tool takes zero parameters, so there is nothing for the description to compensate for; the baseline is 4. The description correctly indicates no input is required to enumerate the sections.

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?

States a specific verb ('Lista') and resource (profile sections) plus the payload content (usual fields per section). It is distinguishable from pure readers like linkedin_profile_read and mutators like linkedin_profile_edit, though it does not explicitly name those siblings as alternatives.

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 explicit when-to-use or when-not-to-use is given, but the 'sections that can be edited' framing implies it is a discovery step before editing. The agent must infer that this is a precursor to the profile_edit family rather than being told.

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 usefully discloses that import consumes a li_at/JSESSIONID from the personal browser and that this lets the session start without login, but says nothing about permission requirements, what happens to an existing session on import, or the sensitivity/storage risks of exported cookies.

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

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

Two tight sentences, front-loading the export/import duality before the use case. Little waste, though the 'útil para' clause is somewhat soft.

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 schema and no annotations, so the description must stand alone; it explains the two actions and their rationale but omits return/error behavior and any file-format guidance beyond what the schema implies. Adequate but with clear gaps for a session-credential tool.

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

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

Schema coverage is 75% and the schema already documents liAt, jsessionid and filePath. The description reinforces that li_at/JSESSIONID are import-only and originate from the personal browser, but adds no format or constraint detail beyond the schema, so baseline 3 applies.

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

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

States specific verbs (export/import) on a specific resource (session cookies), and its purpose is clearly distinct from siblings like linkedin_login and linkedin_session_status. It does not explicitly name those siblings, 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?

Gives clear use cases: backing up the session or starting without going through login. It tells the agent when this is the right tool, though it names no alternatives or exclusions (e.g. when to prefer linkedin_login instead).

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

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

With no annotations, the description carries the burden and does well: it discloses that the session lives in a persistent browser and enumerates the return payload (name, public identifier, cookie expiry). It does not say how a missing/expired session is surfaced (error vs. empty result), which is the remaining 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?

Three short sentences, no wasted words. The purpose leads, the return values follow, and the caller instruction is last — a well-ordered, front-loaded block.

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

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

For a no-parameter status probe with no output schema, the description covers purpose, payload, and call ordering adequately. The only omission is the failure/absent-session behaviour an agent would need to branch on.

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

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

The tool takes zero parameters, so there is nothing to document and the baseline of 4 applies. The description correctly adds no parameter noise.

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?

States a specific verb and resource: it checks whether an active LinkedIn session exists in the persistent browser. It also names the returned fields, making the read-only nature unmistakable, though it does not explicitly distinguish itself from neighbours like linkedin_login or linkedin_session_cookies.

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?

"Llama a esto antes que nada" gives explicit ordering guidance — call it first, before any authenticated action. It stops short of naming alternatives or stating what to do if no session is found, so it is clear context without full exclusion logic.

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

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

No annotations are provided, so the description carries the full burden. It discloses the returned content (today's action counts vs daily caps, plus an interaction log), which implies a read-only status operation, but it never states there are no side effects, nor mentions auth or rate-limit 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?

A single well-formed sentence with the resource reported front-loaded and no filler. It could still be slightly tightened or split to separate the counts from the interaction log, but it is efficient.

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

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

For a simple read-only usage tool with one optional parameter and no output schema, the description covers the return content adequately. It is incomplete regarding the meaning of 'showOutreach' and any behavioral side effects, which an agent would need.

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 parameter 'showOutreach' is entirely undocumented in both schema and description. The description does not compensate for this gap, leaving the agent unable to know what the flag controls.

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?

States a specific verb ('Muestra') and resource (daily action counts against daily limits plus the interaction log), so the tool's purpose is clear. It does not, however, explicitly distinguish itself from siblings like linkedin_applications_log or linkedin_session_status, which is why 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 explains what the tool reports but gives no explicit when-to-use, when-not-to-use, or alternative. The reader can infer it is for checking remaining daily capacity, but nothing states that or names a sibling instead.

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

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

With no annotations, the description carries the full load and does disclose meaningful behavior: it reuses the browser session, is not a public API, routes change without warning, and failures should be treated as normal. It omits auth/session prerequisites and the fact that the method enum permits destructive writes (DELETE/PUT), but the fragility and error-tolerance disclosure is genuinely valuable.

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

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

Three tight sentences that front-load the core purpose before the caveats. No filler, though the caveat sentences could be marginally compressed.

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 annotations and no output schema, so the description must do more, and it does warn about volatility and error handling. However, it never covers the write capability implied by POST/PUT/DELETE (it frames the tool as 'para leer datos'), return format, or parameter meaning, leaving gaps for a 3-parameter request tool.

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

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

Schema coverage is only 33% – only 'path' is described – and the description adds nothing about parameter semantics. It never explains the path format, the meaning of 'method' variants, or the shape of 'body', leaving 'body' and 'method' essentially undocumented.

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

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

The description states a specific verb and resource ('Llamada directa a la API interna de LinkedIn (Voyager) reutilizando la sesión del navegador'), which is unambiguous. It positions itself as the low-level escape hatch versus the many higher-level siblings by calling itself an 'atajo avanzado' for data the UI doesn't expose comfortably.

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

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

It gives a clear condition for use (reading data the interface doesn't expose comfortably) and a fallback ('usa las otras herramientas') when the call fails. It stops short of naming specific alternatives or exclusions beyond 'the other tools', so it falls just below fully explicit guidance.

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