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

With no annotations provided, the description carries full burden but only states the basic action without disclosing behavioral traits. It doesn't mention authentication needs (though 'token' parameter hints at it), potential side effects, error conditions, rate limits, or what happens on success. The description is minimal and lacks critical operational context.

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

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

The description is a single, efficient sentence in Turkish that directly states the tool's purpose with zero wasted words. It's appropriately sized and front-loaded, making it easy to parse quickly.

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

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

For a creation tool with 9 parameters, no annotations, and no output schema, the description is insufficiently complete. It doesn't explain what the tool returns, error handling, or important behavioral aspects like whether duplicates are allowed. The high parameter count and mutation nature require more context than 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 100%, so parameters are well-documented in the schema itself. The description adds no additional parameter semantics beyond what's in the schema. Baseline 3 is appropriate when the schema does the heavy lifting, though the description doesn't compensate or enhance parameter understanding.

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 'Yeni telefon görüşmesi transkripti ekler' clearly states the action (adds/ekler) and resource (new phone call transcript/yeni telefon görüşmesi transkripti). It distinguishes from siblings like 'update_call_transcript' by specifying 'new' but doesn't fully differentiate from all other tools beyond the obvious transcript-related ones.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'update_call_transcript' or 'search_call_transcripts'. It doesn't mention prerequisites, context for creation, or any exclusions. Usage is implied by the action but not explicitly stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Yeni kullanıcı ekler' only states the action without any details on permissions required, whether the operation is idempotent, what happens on duplicate entries, error conditions, or the response format. For a mutation tool with zero annotation coverage, this is a critical gap that leaves the agent guessing about important behavioral traits.

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

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

The description is extremely concise with just three words ('Yeni kullanıcı ekler'), making it front-loaded and efficient. There's zero waste or redundancy—every word contributes directly to stating the tool's purpose. This is an example of optimal brevity for a simple action description.

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

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

Given the complexity of a user creation tool with 10 parameters, no annotations, and no output schema, the description is incomplete. It fails to address critical context such as authentication requirements, permission levels, what the tool returns upon success or failure, and how it differs from similar tools like 'register'. The agent lacks sufficient information to use this tool effectively in a real-world scenario.

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

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

Schema description coverage is 100%, with all 10 parameters clearly documented in Turkish (e.g., 'Kullanıcı adı' for name, 'E-posta adresi' for email). The description adds no parameter information beyond what the schema provides. According to the rules, when schema coverage is high (>80%), the baseline score is 3 even with no param info in the description, which applies here.

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

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

The description 'Yeni kullanıcı ekler' (Adds new user) clearly states the verb ('adds') and resource ('user'), making the purpose immediately understandable. It distinguishes from siblings like 'update_user' or 'delete_user' by specifying creation rather than modification or removal. However, it doesn't specify what kind of user (e.g., system user, employee) or in what context, leaving some ambiguity.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., authentication, permissions), when not to use it (e.g., for existing users), or direct alternatives like 'register' or 'update_user'. The agent must infer usage from the name alone, which is insufficient for optimal tool selection.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action (password change) but doesn't mention critical behavioral aspects: whether this requires authentication (implied by token parameter but not stated), if it's destructive (password changes are irreversible), rate limits, error conditions, or what happens on success. For a security-sensitive mutation 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?

The description is a single, efficient sentence in Turkish that directly states the tool's purpose with zero wasted words. It's appropriately sized for a straightforward tool and front-loads the essential information without unnecessary elaboration.

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

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

For a password change tool with no annotations and no output schema, the description is insufficient. It doesn't cover authentication requirements, security implications, success/failure behavior, or return values. Given the complexity and sensitivity of password operations, the description should provide more context about how the tool behaves and what to expect.

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

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

Schema description coverage is 100%, with all three parameters (token, oldPassword, newPassword) clearly documented in the schema. The description doesn't add any parameter-specific information beyond what's in the schema. The baseline score of 3 reflects adequate parameter documentation through the schema alone, with no additional value from the description.

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

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

The description 'Kullanıcı şifresini değiştirir' (Changes user password) clearly states the verb (change) and resource (user password) in a specific action. It distinguishes from siblings like 'login', 'register', and 'update_user' by focusing specifically on password modification rather than general user updates or authentication actions.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., user must be logged in), when not to use it (e.g., for password reset vs. change), or how it differs from related tools like 'update_user' which might also handle password updates. The agent must infer usage from context alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Kullanıcıyı siler' only states the action without any details about permissions required, whether deletion is permanent or reversible, side effects (e.g., associated data cleanup), error conditions, or response format. For a destructive operation with zero annotation coverage, this is dangerously inadequate.

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

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

The description is a single phrase 'Kullanıcıyı siler', which is overly concise to the point of under-specification. While it avoids verbosity, it fails to provide essential context for a destructive tool. Every sentence should earn its place, but this one doesn't deliver enough value—it's not conciseness but insufficiency.

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

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

Given the tool's complexity (destructive user deletion), lack of annotations, and no output schema, the description is severely incomplete. It doesn't address critical aspects like authentication needs, irreversible consequences, or what happens post-deletion. For a high-stakes operation among many sibling tools, this leaves the agent unprepared to use it safely or effectively.

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

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

The input schema has 100% description coverage, with the single parameter 'id' clearly documented as 'Silinecek kullanıcının ID'si' (ID of the user to be deleted). The description doesn't add any parameter details beyond the schema, but with high schema coverage and only one parameter, the baseline is appropriately high. No compensation is needed.

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

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

The description 'Kullanıcıyı siler' (Deletes the user) is a tautology that merely restates the tool name 'delete_user' in Turkish. While it clearly indicates the action (delete) and resource (user), it doesn't differentiate from sibling tools like 'update_user' or 'add_user' beyond the obvious verb difference. It lacks specificity about what 'delete' entails in this context.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., user must exist), exclusions (e.g., cannot delete self), or related tools like 'update_user' or 'list_users'. With siblings including user management tools, this omission is significant and leaves the agent guessing about appropriate contexts.

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 admin-only restriction, which is a key behavioral trait. However, it lacks details on other aspects like rate limits, pagination (implied by 'limit' parameter but not explained), error handling, or what 'all audit logs' entails (e.g., time range, format). For a tool with no annotations, this is a significant gap.

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

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

The description is a single, efficient sentence in Turkish ('Tüm audit logları getirir (Sadece admin)'), which translates to 'Gets all audit logs (Only admin)'. It's front-loaded with the core purpose and includes a critical constraint in parentheses, with zero wasted words.

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

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

Given the complexity (admin-restricted retrieval tool with 2 parameters), no annotations, and no output schema, the description is minimally adequate. It covers the purpose and access restriction but lacks details on behavior, output format, or error cases. For a tool with no structured support, it should do more to be 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 schema already documents both parameters ('token' as JWT token and 'limit' with default 200). The description doesn't add any meaning beyond this, such as explaining why the token is required or how 'limit' affects performance. Baseline 3 is appropriate when the schema handles parameter documentation.

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

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

The description clearly states the verb ('getirir' meaning 'gets/retrieves') and resource ('tüm audit logları' meaning 'all audit logs'), making the purpose specific. However, it doesn't explicitly distinguish this from sibling tools like 'get_audit_logs_by_category' or 'get_audit_logs_by_date', which would require mentioning that this tool retrieves all logs without filtering.

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 includes implicit usage guidance by specifying 'Sadece admin' (meaning 'Only admin'), indicating it's restricted to admin users. However, it doesn't provide explicit alternatives (e.g., when to use this vs. 'get_audit_logs_by_category') or exclusions, leaving some ambiguity about when this tool is preferred over 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves logs, implying a read-only operation, but doesn't mention any behavioral traits like authentication requirements (though the 'token' parameter hints at this), rate limits, pagination, or what the response format looks like. For a tool with no annotation coverage, this is a significant gap in transparency.

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

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

The description is concise and front-loaded in a single sentence, stating the core purpose efficiently. However, it includes a parenthetical note '(Admin/Manager)' that adds context but could be integrated more smoothly. Overall, it's appropriately sized with minimal waste.

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

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

Given the tool's complexity (3 parameters, no annotations, no output schema), the description is incomplete. It lacks details on behavioral aspects (e.g., authentication, response format), doesn't differentiate from siblings, and provides minimal usage guidance. For a tool that likely returns structured audit log data, more context is needed to help the agent use it effectively.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters (token, category, limit) with descriptions. The description adds no additional parameter semantics beyond what's in the schema—it doesn't explain the category options in more detail or provide context for the limit parameter. 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?

The description clearly states the tool's purpose: 'getirir' (retrieves/fetches) 'audit logları' (audit logs) for a 'belirli kategorideki' (specific category). It specifies the resource (audit logs) and the filtering criterion (category). However, it doesn't explicitly differentiate from sibling tools like 'get_all_audit_logs' or 'get_audit_logs_by_date', which would be needed for a score 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?

The description provides minimal guidance: it mentions the tool is for 'Admin/Manager' roles, implying usage context, but doesn't specify when to use this tool versus alternatives like 'get_all_audit_logs' or 'get_audit_logs_by_date'. There's no explicit when/when-not or alternative tool recommendations, leaving the agent to infer usage based on parameter needs.

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

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

With no annotations provided, the description carries full burden but offers minimal behavioral insight. It mentions role requirements (Admin/Manager) which is useful context, but doesn't disclose other traits like whether this is read-only, pagination behavior, rate limits, error conditions, or what the return format looks like. The description doesn't contradict annotations since none exist.

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

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

The description is a single, efficient sentence that states the core purpose upfront. The parenthetical role requirement adds necessary context without verbosity. No wasted words or redundant information.

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

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

For a read operation with 4 parameters and no output schema, the description is minimally adequate. It covers the what (get audit logs) and who (Admin/Manager) but lacks information about return format, error handling, or behavioral constraints. With no annotations and no output schema, more completeness would be helpful for agent understanding.

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

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

Schema description coverage is 100%, so the schema already fully documents all 4 parameters. The description adds no additional parameter information beyond what's in the schema (it doesn't explain token authentication, date format details, or limit behavior). Baseline 3 is appropriate when schema does all the parameter documentation work.

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

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

The description clearly states the tool's purpose: 'getirir' (gets/fetches) audit logs within a specific date range. It specifies the resource (audit logs) and scope (date range), but doesn't explicitly differentiate from sibling tools like 'get_all_audit_logs' or 'get_audit_logs_by_category' beyond the date focus.

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

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

The description implies usage context with '(Admin/Manager)', suggesting it's for users with those roles, but doesn't explicitly state when to use this tool versus alternatives like 'get_all_audit_logs' or 'get_audit_logs_by_category'. No clear exclusions or prerequisites are provided beyond the implied role requirement.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states what the tool does (retrieves analytics) without any details on permissions, rate limits, data format, or potential side effects. For a tool with no annotations, this is insufficient to inform the agent about behavioral traits.

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

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

The description is a single, clear sentence in Turkish: 'Çağrı analitikleri ve istatistikleri getirir'. It is front-loaded with the core purpose, has no unnecessary words, and efficiently communicates the tool's function without waste.

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

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

Given the complexity of analytics retrieval, no annotations, and no output schema, the description is incomplete. It does not explain what analytics are returned, the format of the data, or any constraints (e.g., date ranges, aggregation methods). This leaves significant gaps for the agent to understand the tool's full context.

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

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

Schema description coverage is 100%, meaning all parameters (token, date, period) are documented in the schema. The description does not add any additional meaning or context beyond what the schema provides, such as explaining how parameters interact or default behaviors. Baseline score of 3 is appropriate as the schema handles parameter documentation adequately.

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

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

The description clearly states the tool's purpose: 'Çağrı analitikleri ve istatistikleri getirir' (retrieves call analytics and statistics). It specifies the verb 'getirir' (retrieves) and resource 'call analytics and statistics', making it understandable. However, it does not differentiate from siblings like 'get_call_transcript_by_id' or 'list_call_transcripts', which also retrieve call-related data, so it lacks sibling 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?

The description provides no guidance on when to use this tool versus alternatives. It does not mention any context, prerequisites, or exclusions, such as how it differs from other analytics tools or when to prefer it over general call retrieval tools. This leaves the agent without clear usage instructions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states what the tool does (retrieves a transcript by ID) without mentioning whether it's a read-only operation, requires authentication (implied by token parameter but not described), has rate limits, or what happens on errors (e.g., invalid ID). For a tool with no annotations, this leaves significant gaps in understanding its behavior.

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

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

The description is a single, efficient sentence in Turkish that directly states the tool's purpose without unnecessary words. It's appropriately sized for a simple retrieval tool and front-loaded with the core action. Every part of the sentence earns its place by specifying the resource and identifier method.

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

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

Given no annotations and no output schema, the description is incomplete for a tool with authentication requirements and potential behavioral complexities. It doesn't explain what the tool returns (e.g., transcript content, error formats) or address authentication needs beyond the implied token parameter. For a tool with 2 required parameters and security implications, more context is needed.

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

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

The input schema has 100% description coverage, with clear documentation for both parameters ('token' as JWT token, 'id' as transcript ID). The description adds no additional meaning beyond what the schema provides—it doesn't explain parameter interactions, format requirements (e.g., numeric ID constraints), or usage context. Baseline score of 3 is appropriate since the schema does the heavy lifting.

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

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

The description clearly states the verb ('getirir' - gets/fetches) and resource ('telefon transkripti' - phone transcript) with a specific identifier constraint ('ID'ye göre' - by ID). It distinguishes from siblings like 'list_call_transcripts' and 'search_call_transcripts' by specifying retrieval of a single transcript by ID rather than listing or searching. However, it doesn't explicitly contrast with 'get_call_analytics' which might also involve transcripts.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'list_call_transcripts' or 'search_call_transcripts'. It doesn't mention prerequisites (e.g., authentication via token) or exclusions (e.g., not for bulk retrieval). The context is implied through the parameter 'id' but not explicitly stated in the description text.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions retrieving logs but lacks details on permissions required, rate limits, pagination, error handling, or response format. For a read operation with zero annotation coverage, this is insufficient to inform safe and effective use.

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

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

The description is a single, efficient sentence in Turkish that directly states the tool's purpose without unnecessary words. It is appropriately sized and front-loaded, with every word contributing to understanding the core function.

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

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

Given the complexity of audit log retrieval, lack of annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects like authentication needs, data scope, or return values, leaving significant gaps for the agent to operate effectively in this context.

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

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

Schema description coverage is 100%, with clear descriptions for both parameters ('token' as JWT token, 'limit' as number of logs with default 50). The description adds no additional parameter semantics beyond what the schema provides, so it meets the baseline for high coverage without compensating value.

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

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

The description clearly states the action ('getirir' - fetches/retrieves) and the resource ('kendi audit loglarını' - own audit logs), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_all_audit_logs' or 'get_audit_logs_by_category', which would be needed for a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'get_all_audit_logs' or 'get_audit_logs_by_date'. It simply states what it does without context about appropriate scenarios or exclusions, leaving the agent to infer usage 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool lists permissions but doesn't describe what 'listeler' entails—e.g., format (array of strings, structured objects), scope (current user only, as implied by 'my'), or any side effects (likely read-only, but not confirmed). For a tool with no annotation coverage, this minimal description leaves key behavioral traits unspecified.

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

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

The description is a single, efficient sentence in Turkish that directly states the tool's purpose without fluff. It's appropriately sized for a simple tool, though it could be slightly more informative (e.g., adding context). There's no wasted verbiage, and it's front-loaded with the core action, earning a high score for conciseness.

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

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

Given the complexity (a read operation with one parameter) and lack of annotations or output schema, the description is incomplete. It doesn't explain the return value (e.g., what permissions look like), error conditions, or authentication requirements implied by the token. For a tool that likely involves user data and permissions, this leaves significant gaps for an AI agent to infer usage correctly.

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

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

The input schema has 100% description coverage (the 'token' parameter is documented as a JWT token), so the baseline is 3. The description adds no additional meaning about parameters—it doesn't explain why a token is needed or how it relates to listing permissions. Since the schema already covers the parameter, the description doesn't compensate but doesn't detract either, meeting the minimum viable baseline.

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

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

The description clearly states the tool's purpose: 'Kullanıcının sahip olduğu yetkileri listeler' (Lists the permissions the user has). It specifies the verb 'listeler' (lists) and the resource 'yetkiler' (permissions), and distinguishes itself from sibling tools like get_user_by_id or get_my_audit_logs by focusing on permissions. However, it doesn't explicitly differentiate from potential permission-related siblings (none exist in the list), so it falls short of a perfect 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., authentication via token), use cases (e.g., checking access before an action), or exclusions (e.g., not for admin-level permissions). With sibling tools like get_user_by_id or get_my_audit_logs that might overlap in user context, the lack of differentiation is a clear gap.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions authorization is required ('Yetki gerekli'), which is useful context about authentication needs. However, it lacks details on rate limits, error handling, what specific user information is returned, or any side effects. For a read operation with zero annotation coverage, this leaves significant gaps in understanding the tool's behavior.

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

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

The description is a single, concise sentence in Turkish that states the purpose and notes authorization. It's front-loaded with the core function and avoids unnecessary details. However, it could be slightly more structured by separating the authorization note, but overall it's efficient with minimal waste.

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

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

Given the complexity (a read operation with authorization), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what user information is retrieved, the response format, error cases, or how authorization works with the token. For a tool that requires authentication and returns data, this leaves too much unspecified for effective agent use.

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

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

Schema description coverage is 100%, with both parameters ('id' and 'token') documented in the schema. The description adds no additional parameter semantics beyond what's in the schema—it doesn't explain format constraints, examples, or usage nuances. With high schema coverage, the baseline score of 3 is appropriate as the schema handles parameter documentation adequately.

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

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

The description clearly states the tool's purpose: 'ID'ye göre kullanıcı bilgilerini getirir' translates to 'retrieves user information by ID', which is a specific verb+resource combination. However, it doesn't explicitly distinguish this tool from sibling tools like 'get_user' or 'list_users' (though 'list_users' appears in siblings, suggesting potential overlap). The description is clear but lacks sibling differentiation.

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

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

The description provides minimal guidance: it mentions 'Yetki gerekli' (authorization required), which hints at a prerequisite but doesn't specify when to use this tool versus alternatives like 'list_users' or 'search_users'. There's no explicit when/when-not usage, no comparison to siblings, and no context for choosing this specific retrieval method over others.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure but offers minimal information. It doesn't mention whether this is a read-only operation, what permissions are required, how results are returned (pagination, format), or any rate limits. The description only states the basic action without behavioral context.

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

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

The description is a single, efficient sentence in Turkish that directly states the tool's function without unnecessary words. It's appropriately sized and front-loaded with the essential information, making it highly concise and well-structured.

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

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

For a tool with 4 parameters, no annotations, and no output schema, the description is insufficiently complete. It doesn't explain what the tool returns, how results are structured, or provide behavioral context needed for proper usage. The agent would need to rely heavily on the schema alone, which is inadequate for comprehensive understanding.

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

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

The input schema has 100% description coverage, providing clear documentation for all 4 parameters. The tool description adds no additional parameter information beyond what's already in the schema, so it meets the baseline expectation but doesn't enhance understanding of parameter usage or semantics.

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

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

The description clearly states the verb ('listeler' - lists) and resource ('Telefon görüşmeleri transkriptlerini' - phone call transcripts), making the purpose immediately understandable. However, it doesn't distinguish this tool from its sibling 'search_call_transcripts', which appears to serve a similar function, preventing a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'search_call_transcripts' or 'get_call_transcript_by_id'. There's no mention of prerequisites, context, or exclusions, leaving the agent with insufficient usage direction.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions authorization requirements, which is valuable context. However, it doesn't describe what 'listeler' entails (e.g., pagination, sorting, format of returned data, rate limits, or whether it's a read-only operation), leaving significant gaps in behavioral understanding.

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

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

The description is a single, efficient sentence that states the purpose and authorization requirement without any wasted words. It's appropriately sized and front-loaded with essential 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 tool with one parameter (fully documented in schema) and no output schema, the description is minimally adequate. It covers the basic purpose and authorization need but lacks details on output format, behavioral traits (like pagination), and differentiation from siblings, which would enhance completeness given the tool's role in a user management context.

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

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

Schema description coverage is 100%, with the single parameter 'token' documented as a JWT token for authorization control. The description doesn't add any meaning beyond what the schema provides (e.g., it doesn't explain token acquisition or format details), so it meets the baseline for high schema coverage without compensation.

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

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

The description clearly states the verb ('listeler' - lists) and resource ('tüm kullanıcıları' - all users), making the purpose unambiguous. However, it doesn't differentiate from sibling tools like 'search_users' or 'get_user_by_id', which prevents a perfect score.

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 mentions authorization is required ('Yetki gerekli'), which provides some context about prerequisites. However, it offers no guidance on when to use this tool versus alternatives like 'search_users' or 'get_user_by_id', nor does it specify any exclusions or specific scenarios for its use.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. While it mentions authentication and token acquisition, it doesn't cover critical aspects like required permissions, rate limits, error conditions, or what happens on successful/failed login. For a security-sensitive 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?

The description is extremely concise - a single sentence that directly states the tool's purpose and outcome. There's zero wasted language, and it's appropriately front-loaded with the essential 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 critical authentication tool with no annotations and no output schema, the description is insufficient. It doesn't explain the JWT token format, expiration, usage, or error responses. Given the security implications and lack of structured metadata, the description should provide more complete context.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (email and password) adequately. The description doesn't add any meaningful parameter semantics beyond what's in the schema, maintaining the baseline score for high schema coverage.

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

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

The description clearly states the action ('giriş yapar' - logs in) and the outcome ('JWT token alır' - gets JWT token), providing a specific verb and resource. However, it doesn't differentiate from the sibling 'register' tool, which handles user creation rather than authentication.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'register' for new users or 'verify_token' for token validation. It simply states what the tool does without context about prerequisites or appropriate scenarios.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states it creates a new user registration but doesn't mention authentication requirements, whether it's idempotent, what happens on duplicate emails, or what the response looks like. For a mutation tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence in Turkish that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, with zero wasted content.

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

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

For a user registration tool with 6 parameters (5 required) and no annotations or output schema, the description is inadequate. It doesn't explain the registration process, success/failure responses, or how it differs from similar tools like 'add_user'. The agent lacks context about what 'registration' entails beyond basic parameter passing.

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

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

Schema description coverage is 100%, with all parameters well-documented in Turkish. The description doesn't add any parameter-specific information beyond what's in the schema, such as format constraints or examples. With high schema coverage, the baseline score of 3 is appropriate as the schema does the heavy lifting.

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

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

The description 'Yeni kullanıcı kaydı oluşturur' (Creates new user registration) clearly states the verb ('oluşturur' - creates) and resource ('kullanıcı kaydı' - user registration). It distinguishes from siblings like 'add_user' by specifying 'new registration' context, though not explicitly contrasting with 'add_user' which might serve a similar purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'add_user' or 'login'. There's no mention of prerequisites, context (e.g., for new users vs. existing users), or exclusions, leaving the agent to infer usage from the tool 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?

No annotations are provided, so the description carries the full burden. It states the tool searches for keywords in transcripts, implying a read-only operation, but doesn't disclose behavioral traits like authentication needs (implied by the 'token' parameter), rate limits, or what the search returns (e.g., results format, pagination). This is a significant gap for a tool with no annotation coverage.

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

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

The description is a single, efficient sentence in Turkish that directly states the tool's purpose without unnecessary words. It is appropriately sized and front-loaded, with every word earning its place.

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

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

Given no annotations, no output schema, and 3 parameters, the description is incomplete. It doesn't explain the return values, authentication requirements (beyond the token parameter), or how results are structured, leaving gaps for a search tool that likely returns complex data.

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

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

The schema description coverage is 100%, so the schema already documents all parameters (token, query, searchIn) with descriptions and an enum. The description adds no additional meaning beyond what the schema provides, such as examples or usage notes, but the baseline is 3 when schema coverage is high.

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 'Transkriptlerde anahtar kelime arama yapar' clearly states the tool's purpose: searching for keywords in transcripts. It specifies the verb (search) and resource (transcripts), though it doesn't explicitly differentiate from sibling tools like 'list_call_transcripts' or 'search_users', which would require a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'list_call_transcripts' for unfiltered listing or 'search_users' for different resources, nor does it specify prerequisites or contexts for usage.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states what the tool does (searching) but doesn't describe how it behaves: whether it's read-only, what permissions are needed, if it returns partial matches, pagination details, or error conditions. For a search tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence that directly states the tool's function without unnecessary words. It's appropriately sized and front-loaded with the core purpose, making it easy for an agent to parse quickly.

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

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

Given the complexity of a search operation, lack of annotations, and no output schema, the description is incomplete. It doesn't explain what the search returns (e.g., list of users, partial matches), any limitations (e.g., case sensitivity, wildcards), or error handling. For a tool with no structured behavioral data, the description should provide more operational context.

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

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

The schema description coverage is 100%, with the single parameter 'query' documented as 'Arama terimi' (search term). The description adds marginal value by specifying what fields the search covers (name, email, department, position), but doesn't provide additional syntax, format, or matching rules beyond what the schema implies. This meets the baseline for high schema coverage.

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

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

The description clearly states the tool's purpose: searching users by specific attributes (name, email, department, or position). It uses a specific verb ('arar' - search) and identifies the resource ('kullanıcıları' - users). However, it doesn't explicitly differentiate from sibling tools like 'list_users' or 'get_user_by_id', which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to prefer 'search_users' over 'list_users' (for filtered searches) or 'get_user_by_id' (for direct ID lookup), nor does it specify any prerequisites or exclusions. This leaves the agent without contextual usage instructions.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. 'Günceller' (updates) implies a mutation operation, but the description doesn't disclose important behavioral traits: what permissions are required, whether the operation is idempotent, what happens to unspecified fields, error conditions, or response format. For a mutation tool with zero annotation coverage, this leaves significant gaps.

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

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

The description is a single, efficient sentence that gets straight to the point with zero wasted words. It's appropriately sized for a tool with good schema documentation and follows the principle of front-loading the core purpose.

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

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

For a mutation tool with 5 parameters, no annotations, and no output schema, the description is incomplete. It doesn't address critical context: what fields can be updated, what the response contains, error handling, or authentication requirements. The agent must rely heavily on the parameter schema and trial-and-error to understand this tool's behavior.

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

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

Schema description coverage is 100%, so all parameters are documented in the schema. The description adds no additional parameter semantics beyond the generic 'updates existing transcript' statement. It doesn't explain relationships between parameters, provide examples, or clarify edge cases. The baseline score of 3 reflects adequate but minimal value added beyond the schema.

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

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

The description 'Mevcut transkripti günceller' (Updates existing transcript) clearly states the action (günceller/update) and resource (transkript/transcript). It distinguishes from sibling tools like 'add_call_transcript' by specifying it updates existing records rather than creating new ones. However, it doesn't specify what aspects of the transcript are updated beyond the general concept.

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

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

The description provides no guidance on when to use this tool versus alternatives. There's no mention of prerequisites (like needing an existing transcript ID), when not to use it, or how it differs from similar operations. The agent must infer usage from the tool name and parameter schema 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 provided, the description carries full burden for behavioral disclosure. It states this is an update operation, implying mutation, but doesn't mention required permissions, whether changes are reversible, potential side effects, or error conditions. For a mutation tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence in Turkish that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, with zero wasted content.

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

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

For a mutation tool with 5 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what happens when fields are omitted, what the return value looks like, or any behavioral constraints. The agent lacks crucial context for proper tool invocation.

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

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

Schema description coverage is 100%, with all 5 parameters well-documented in the schema (id, name, email, department, position). The description doesn't add any parameter-specific information beyond what's already in the schema, so it meets the baseline of 3 where the schema does the heavy lifting.

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

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

The description 'Mevcut kullanıcı bilgilerini günceller' (Updates existing user information) clearly states the verb (günceller/updates) and resource (kullanıcı/user), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'add_user' or 'change_password', which would require more specific scope definition to earn a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'add_user' (for creating new users) or 'change_password' (for password-specific updates). There's no mention of prerequisites, context, or exclusions, leaving the agent with minimal usage direction.

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

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

No annotations are provided, so the description carries full burden. It states the tool checks token validity but doesn't disclose behavioral traits like what happens on success/failure (e.g., returns boolean, error messages), whether it performs network calls, rate limits, or side effects. This is a significant gap for a tool with no annotation coverage.

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

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

The description is a single, efficient sentence in Turkish, front-loaded with the core purpose. It's appropriately sized for a simple tool, though it could be slightly more informative without losing conciseness.

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

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

Given no annotations, no output schema, and a simple input schema, the description is incomplete. It lacks details on return values (e.g., success/failure indicators), error handling, or operational context, making it inadequate for reliable agent use without additional 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 description coverage is 100%, with the parameter 'token' documented as 'JWT token'. The description adds no additional meaning beyond this, such as format details or examples. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description 'JWT token'ın geçerliliğini kontrol eder' (checks the validity of a JWT token) states a clear verb ('kontrol eder' - checks/verifies) and resource ('JWT token'), but it's vague about what 'validity' means (e.g., signature verification, expiration check, claims validation). It doesn't distinguish from siblings, though no obvious verification siblings exist in the list.

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

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

No guidance on when to use this tool versus alternatives is provided. The description doesn't mention prerequisites (e.g., needing a token), exclusions, or related tools like 'login' or authentication flows, leaving usage context implied but unspecified.

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