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

With no annotations, the description carries the full burden. It implies a write via 'Adds' and shows POST, but never says whether the operation is idempotent when the recipe is already favorited, what permissions are needed, or what is returned/errored.

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 functional sentence and endpoint are front-loaded and short, but the 'Keywords: ...' block is pure filler that merely restates the tool name and synonyms, adding no selection value.

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 two-parameter write tool with no annotations or output schema, the description covers the action and endpoint but omits idempotency, auth expectations, and success/failure behavior that an agent would need to call it 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 coverage is 0%, but the endpoint template '/api/users/{id}/favorites/{slug}' usefully maps id to a user identifier and slug to a recipe identifier, and the schema supplies the uuid4 format for id. It still gives no guidance on where the caller obtains slug or whose user id is expected.

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 line 'Adds a recipe to the user's favorites' states a concrete verb and resource, and the endpoint template shows it is scoped to a user. It is distinguishable from siblings like remove_favorite and get_favorites, though the leading fragments ('Users: Ratings. Create favorite.') add noise rather than precision.

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?

Nothing states when to use this instead of remove_favorite, get_favorites, or set_rating, nor any precondition (e.g., recipe must exist, user must be the caller). Usage is only implied by 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?

With no annotations, the description carries the full behavioral burden and discloses almost nothing: it does not say the operation mutates a shopping list, what happens to existing items, whether it is idempotent, or what permissions are needed. The misleading 'Create recipe' phrase actively adds confusion rather than 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 purpose is front-loaded, but roughly half the text is a ~50-term keyword dump ('recipe, households, shopping, lists, create, add, new, make, write, post, mealie') that consumes space without adding meaning. Wasteful rather than 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?

No annotations, no output schema, and 0% parameter description coverage for a mutating endpoint that takes a complex nested bulk body. An agent cannot determine authentication needs, response shape, or how to construct the body from this definition alone; it covers the endpoint and rough purpose but little else.

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 body is a deeply nested array of ShoppingListAddRecipeParamsBulk objects (recipeId, recipeIngredients, recipeIncrementQuantity) with no field descriptions anywhere. The description compensates only implicitly through its title, giving no semantics for item_id, recipeId, or the increment quantity.

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 title phrase 'Add Recipe Ingredients To List' names a specific verb and resource, so the core purpose is identifiable. However, the immediately following 'Create recipe' contradicts that framing (this endpoint attaches recipe ingredients to an existing shopping list, it does not create a recipe), and there is no differentiation from the sibling 'add_single_recipe_ingredients_to_list' or 'remove_recipe_ingredients_from_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?

There is no guidance on when to use this bulk endpoint versus 'add_single_recipe_ingredients_to_list', nor any prerequisite or context statement. The remainder of the text is a keyword dump, not usage instruction.

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 implies mutation via 'add' and the POST verb, and flags deprecation, but says nothing about permissions, side effects on existing list items, or the presence of a request body (recipeIngredients / recipeIncrementQuantity).

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 deprecation and endpoint are front-loaded, which is good, but the 'Keywords:' block is a long list of near-duplicate search terms (create/add/new/make/write recipe) that bloats the definition without adding meaning.

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

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

This is a mutating tool with no annotations, no output schema, and 0% parameter documentation, so the description should do more work. It names the endpoint but omits request body structure, permissions, and the deprecation replacement, leaving the agent under-informed.

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

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

Schema description coverage is 0% across 3 parameters, and the description adds no meaning for item_id, recipe_id, or the optional body. The keyword block ('post', 'create') adds noise rather than parameter guidance, so it 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 title/name phrase 'Add Single Recipe Ingredients To List' gives a specific verb+resource, and the bracketed POST path pins down the exact endpoint and its two path params. However the body line 'Create recipe' contradicts the add-to-list purpose and the description never distinguishes this single-recipe variant from the sibling add_recipe_ingredients_to_list.

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

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

The '(DEPRECATED)' marker is the only usage signal, and it is not followed by a named replacement such as add_recipe_ingredients_to_list, so an agent is told to avoid the tool but not what to use instead. No context on when adding a recipe's ingredients to a list 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?

No annotations are provided, so the description carries the full disclosure burden. The '[GET /api/app/about]' path and the 'read-only' keyword imply a safe read, but the description says nothing about authentication requirements, rate limits, or what the response contains beyond 'general application information.'

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 bloated with redundant phrases ('Get App Info,' 'App: About,' 'Get about') and an exhaustive keyword dump that duplicates the name. The one useful sentence ('Get general application information') is buried at the end instead of being 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 zero-parameter read tool this is minimally adequate: an agent knows it can call it with no arguments to get app info. But with no output schema, no annotations, and only 'general application information' to describe the return, the agent cannot anticipate what fields or configuration values it will receive.

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 per the rubric the baseline is 4. There is nothing parameter-related for the description to clarify or omit.

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 ends with a substantive statement, 'Get general application information,' which gives the tool a verb and resource. However, the leading phrases ('Get App Info — App: About. Get about.') are largely tautological restatements of the name, and nothing distinguishes this 'general application information' from siblings like get_startup_info or get_app_theme.

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 conditions, and no mention of alternatives. The trailing keyword list ('fetch about, read about, retrieve about') is search fodder, not usage guidance, leaving the agent to infer the tool's role from its 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 behavioral burden. It reveals only that the operation is a POST bulk action, but does not explain whether categories replace or append to existing ones, what permissions are required, or whether the change is reversible.

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 first line identifies the tool, but the remainder is keyword-stuffed SEO text that does not earn its place. The structure is noisy rather than front-loaded with useful details.

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 bulk mutation tool with no annotations and no output schema, the description is inadequate. It omits the body semantics, usage context, and behavioral effects needed to call 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%, and the description does not explain the single required body parameter or its nested 'recipes' and 'categories' fields. The agent gets no semantic guidance beyond the schema's structural titles.

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 largely restates the tool name, cycling through 'Bulk Categorize Recipes' and 'Create categorize' without explaining what categorizing actually means or how it differs from sibling bulk actions like bulk_tag_recipes. The endpoint and keyword list add no clarifying substance.

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

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

There is no guidance on when to use this tool versus alternatives such as bulk_tag_recipes, bulk_settings_recipes, or bulk_delete_recipes. The keyword list provides search terms but no context or exclusions.

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

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

No annotations are provided, so the description carries the full disclosure burden for a destructive bulk operation. It reveals only the route and HTTP method (POST .../bulk-actions/delete); it says nothing about irreversibility, whether deletion is soft or hard, permission requirements, or failure semantics when some IDs are invalid.

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 name and endpoint are front-loaded, but the body is dominated by a long keyword dump that repeats the tool name and adds irrelevant create/add/new verbs. The useful content could fit in one sentence, so most of the text does not earn its place.

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

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

For a destructive bulk mutation with no annotations, no output schema, and an undocumented parameter, the description should at minimum cover the deletion target format and consequences. Instead it stops at the route and keyword padding, leaving the agent without enough to invoke 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?

Schema description coverage is 0% for the single required body parameter containing a 'recipes' array, so the description must compensate and does not. The word 'bulk' weakly implies multiple records per call, but nothing clarifies whether the array holds IDs, slugs, or names, nor any size limit.

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 opening states a specific verb+resource ('Bulk Delete Recipes ... Delete recipe'), so the core action is identifiable. However, there is no differentiation from close siblings such as recipe_crud_delete_one, delete_many, or shared_recipes_delete_one, and the keyword block injects contradictory verbs ('create recipe, add recipe, new recipe, make recipe'), which muddies rather than sharpens the purpose.

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

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

No when-to-use guidance is given: nothing says to prefer this over recipe_crud_delete_one for single deletes or delete_many for other resources, nor any prerequisite (e.g., confirmation, ownership checks). The keyword list is not usage guidance, so the agent gets no routing information.

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 adds almost nothing: it discloses only the HTTP method (POST) via the route. It does not say whether this triggers a background report/job, whether the export is asynchronous, what permissions are needed, or how the result is delivered.

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 useful content is one sentence; the remainder is redundant keyword padding that repeats the tool name and enumerates near-synonyms ('bulk export recipes, export recipe, create recipe, add recipe...'). This bloats the definition and injects noise rather than front-loaded meaning.

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

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

With no annotations, no output schema, and 0% parameter coverage, the description should explain the parameter contract and what the export returns (e.g., a downloadable report). It covers the endpoint only, leaving the agent unable to call it correctly or predict the outcome.

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 required parameter is a nested object (body with recipes[] and an exportType enum). The description says nothing about supplying a recipe list or the accepted export format, so it fails to compensate for the schema gap; only the name loosely implies a recipe list.

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 does identify a verb+resource ('Export recipe') and give the POST endpoint, so the basic action is discernible. However, the trailing keyword list mixes in contradictory verbs — 'create recipe, add recipe, new recipe, make recipe, write recipe' — which muddies whether this tool exports or creates. It also gives no differentiation from siblings such as purge_export_data or create_recipe_from_html_or_json.

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 statement of when to use this tool versus alternatives. The phrase 'Recipe: Bulk Actions' hints at a bulk context but never says when bulk export is appropriate or what distinguishes it from single-recipe retrieval or purge_export_data.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not explain that this is a bulk mutation affecting multiple recipes, what permissions are required, whether existing settings are overwritten, or what the POST response 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?

The definition is dominated by a long SEO-style keyword list that repeats the tool name and generic verbs. Only the endpoint line conveys factual information, and the rest does not earn its place.

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

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

With no annotations, no output schema, and no parameter descriptions, the description should compensate for missing structured guidance. Instead it gives an inaccurate "create" framing and omits the bulk-assignment behavior an agent needs to call it correctly.

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

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

Schema description coverage is 0%, and the description adds no meaning for the single body parameter. It does not explain that body.recipes identifies target recipes or that body.settings contains locked, public, showAssets, and other boolean flags.

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

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

The description says "Create setting" and lists the endpoint, but the input schema shows the tool actually bulk-applies settings to a list of recipes. This makes the purpose misleading rather than simply vague. It also fails to distinguish itself from sibling bulk tools like bulk_tag_recipes or bulk_categorize_recipes.

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 when-to-use guidance, no prerequisites, and no alternatives among the many sibling tools. The keyword list contains "bulk actions" and "recipes" but does not tell an agent when this bulk settings operation is appropriate instead of other bulk recipe tools.

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

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

No annotations are provided, so the description carries the full burden, yet it discloses only that this is a POST to /api/recipes/bulk-actions/tag. It says nothing about whether tags must pre-exist, how duplicates are handled, whether assignment is additive or replacing, or permission 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?

The description is dominated by a long comma-separated keyword-stuffing block ('bulk_tag_recipes, bulk tag recipes, create tag, add tag, new tag, make tag, write tag...') that adds no semantic value. Front-loaded header is present but buried under noise.

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 should compensate heavily. Instead it omits the request body structure, tag/recipe semantics, and any return or error behavior, leaving the definition inadequate for correct invocation.

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

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

Schema description coverage is 0% and the single 'body' parameter is a nested AssignTags object with required 'tags' and 'recipes' arrays. The description provides no explanation of these fields, adding no meaning beyond the bare schema, so an agent cannot learn the required shape from the text.

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 name 'bulk_tag_recipes' and the header 'Bulk Tag Recipes' convey a bulk tagging operation, which is close to the schema's AssignTags (recipes + tags) intent. However, the body text 'Create tag' is imprecise and mildly misleading — the endpoint assigns existing tags to recipes rather than creating a tag. No differentiation from siblings like bulk_categorize_recipes or organizer_tags_create_one.

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, and no mention of alternatives despite many nearby siblings (bulk_categorize_recipes, bulk_settings_recipes, delete_recipe_tag). The tool name implies bulk tagging but the description never states the conditions that select it.

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

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

No annotations are provided, so the description carries full behavioral burden. It says the token is created 'in the Database' but does not disclose whether the token is shown only once, its lifetime, required auth, or that it is a long-lived (LongLiveTokenIn) token. This is a significant gap for a security-sensitive credential-creation tool.

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

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

The core sentence is short and front-loaded, but the trailing keyword list ('create, add, new, make, write, post, mealie') is pure filler that adds no semantic value and bloats the definition.

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 credential-minting mutation with no annotations, no output schema, and 0% parameter documentation, the description should explain token lifetime, visibility, and required permissions. It leaves all of that to guesswork.

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 nested body object is undocumented. The description adds no explanation of the 'name' and optional 'integrationId' (default 'generic') fields, so an agent cannot know what values are valid or what the integration id 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?

States a clear verb+resource: 'Create api token' with the HTTP endpoint POST /api/users/api-tokens. It distinguishes from siblings like get_token, refresh_token, create_invite_token by naming the exact resource, though the keyword spam dilutes the signal.

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 or when-not-to-use guidance. It does not clarify how this long-lived API token differs from get_token, refresh_token, or oauth_login, leaving the agent to infer selection among several token-related 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 behavioral burden, and it discloses almost nothing: no required role/permission, no token expiry or lifecycle, no confirmation that it only creates (not sends) the invitation, no indication of what the response contains. Only the POST verb implies mutation.

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 core sentence is front-loaded and fine, but it is followed by a long keyword-stuffing block that repeats the same terms ('create invitation, add invitation, new invitation, make invitation, write invitation') with no informational value. The useful content is roughly one line out of many.

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 zero parameter documentation, the description should explain permissions, the meaning of 'uses', and how the created token is consumed. None of that is present, leaving the agent unable to call it confidently beyond guessing.

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

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

Schema description coverage is 0% and the description adds no parameter meaning at all. The most important field, 'uses' (presumably how many times the invite token can be redeemed), and the optional groupId/householdId scoping are entirely unexplained in both the schema and 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?

States a specific verb+resource ('Create invitation', 'Create Invite Token') and gives the HTTP route POST /api/households/invitations, so the agent knows what the tool does. However, it never distinguishes itself from close siblings like email_invitation, get_invite_tokens, or create_api_token — the keyword blob lists generic terms ('create', 'add', 'new', 'make', 'write') instead.

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 statement of when to use this versus email_invitation (which presumably sends the invite) or get_invite_tokens (which lists them). The only routing signal is the 'Households: Invitations' grouping and the endpoint path, which the agent must infer.

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 only supplies the HTTP verb and path (POST .../create-bulk). It omits important traits for a bulk mutation: auth requirements, whether it is atomic or partially succeeds, duplicate handling, and whether items are appended or replace existing ones.

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 first two sentences are front-loaded and useful, but they are followed by a long keyword/synonym dump ('create_many, create many, bulk create shopping item... mealie') that is pure noise and inflates the definition without adding meaning.

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

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

For a bulk mutation over a complex nested payload with no annotations and no output schema, the description should explain required inputs, auth, and failure semantics. It supplies only the endpoint, leaving the agent under-informed for a non-trivial write operation.

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

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

The single 'body' parameter is an array of ShoppingListItemCreate with 0% schema description coverage, and the description says nothing about the payload shape, the required shoppingListId, or the per-item fields (food, unit, quantity, position). An agent gets no semantic help about parameters 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 states a specific verb and resource: 'Bulk create shopping item' scoped to 'Households: Shopping List Items', which is clearer than the bare name 'create_many'. It does not, however, explicitly contrast itself with siblings like households_shopping_list_items_create_one, so the reader must infer that 'bulk' is the distinguishing factor.

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 when to prefer this bulk endpoint over households_shopping_list_items_create_one vs add_recipe_ingredients_to_list, nor any prerequisite such as needing an existing shopping list id. The keyword list adds no routing information.

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. It does disclose genuine behavior beyond the name: selection is governed by household mealplan rules and degrades to an arbitrary meal when no rules exist. It does not say that this writes a new entry into the mealplan, what a non-random repeated call would do, or whether permissions are required, leaving meaningful gaps for a mutation route.

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 useful content is two sentences; the rest is a long keyword dump ('Keywords: create_random_meal, create random meal, create random, add random ... mealie') that repeats the tool name and synonyms without adding semantics. Space that could document the input parameter is spent on SEO 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?

There is no output schema and no annotations, so the description should cover what is created and returned, plus permission requirements. Instead it explains only the randomization rule source; the actual artifact created (a dated mealplan entry of a randomly chosen recipe) and the response shape are unstated, and the sole parameter is undocumented.

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

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

Schema description coverage is 0%, and the description adds nothing about the single required 'body' parameter — it never mentions 'date' (the sole required field) or 'entryType' (which defaults to 'dinner'). An agent must open the schema to learn anything about inputs, and even then the enum values for entryType carry no explanation.

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: it creates a randomly-selected mealplan entry under a household, via POST /api/households/mealplans/random. That distinguishes it reasonably well from the sibling households_mealplans_create_one (manual entry creation), though the sibling is never named. The scattered keyword block dilutes but does not obscure the core statement.

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

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

It explains the operating context (randomization follows the household's mealplan settings, falling back to any random meal if none exist) and points to the mealplan settings routes. However, it never states when to prefer this over households_mealplans_create_one, nor any prerequisites or side effects, so usage is only implied.

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

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

With no annotations, the description carries the full behavioral burden. It reveals the method (POST) and that content is "parsed like a URL", but says nothing about authentication requirements, whether duplicates are created, what the response returns, or how parsing failures are handled.

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 substantive content is front-loaded and reasonably tight, but the trailing keyword list is pure SEO padding that repeats the name and adds no decision-relevant information, bloating the definition.

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 documentation, the description leaves too much unsaid: no return shape, no permissions/auth context, and no explanation of the required nested body object.

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

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

Schema description coverage is 0%, so the description must compensate. It only loosely explains the required "data" string (HTML or schema.org JSON) and completely omits the "url", "includeTags", and "includeCategories" fields and the "body" wrapper structure that the schema requires.

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 ("Create recipe") and clarifies the accepted input formats: raw HTML or a schema.org Recipe JSON string. The name itself distinguishes it from the zip/image siblings, but the description never names or contrasts those alternatives 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 through the input-format constraint ("Takes in raw HTML or a https://schema.org/Recipe object as a JSON string"), which implicitly routes agents here rather than to create_recipe_from_zip, create_recipe_from_image, or parse_recipe_url. No explicit when-to-use or exclusion guidance is given.

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 OpenAI performs the extraction, implying external processing, but says nothing about auth requirements, failure/error behavior, cost, or what happens to the uploaded image. This is thin 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?

The core sentence is efficient, but the 'Create image.' fragment and a long trailing keyword dump (recipe crud, recipes, create, add, new, make, write, post, mealie) are low-value filler that dilute the front-loaded message.

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

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

For a two-parameter, no-annotation, no-output-schema write tool that ingests uploaded files, the description omits auth/permission context, supported image types, failure modes, and return behavior. It covers the headline purpose but not enough for an agent to call 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?

Schema coverage is 50%; the description adds meaning for translateLanguage ('a language for it to translate the recipe to'), clarifying intent beyond the bare field name. The images upload parameter's semantics (absolute local paths) are only in the schema, so the description does not fully 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+resource ('Create a recipe from an image using OpenAI') that clearly distinguishes it from other ingestion siblings like create_recipe_from_html_or_json or parse_recipe_url. The noise fragment 'Create image.' blurs it slightly, and no sibling is named explicitly, but the core purpose is unmistakable.

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 notes that a translation language can optionally be supplied, which is usage-adjacent, but never says when to choose this tool over create_recipe_from_html_or_json, create_recipe_from_zip, or parse_recipe_url. No prerequisites or exclusions are given.

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 delivers almost nothing beyond 'creates a recipe'. It does not say whether this mutation is idempotent, what happens on a malformed archive, whether the recipe is merged or duplicated, or what auth/permissions are needed. The method/path is disclosed but that is the only behavioral signal.

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 header is front-loaded and readable, but the trailing 'Keywords:' list is pure filler that repeats the tool name in multiple near-synonymous forms. That block consumes roughly half the text and earns nothing for an agent trying to decide whether to call the 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 mutation tool with no annotations and no output schema, the description should at minimum clarify auth needs, expected archive contents, and the resulting behavior. It instead provides retrieval keywords, leaving the agent without enough context to distinguish this from the other recipe-creation siblings.

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 single 'archive' parameter is already documented in the schema as a file field requiring an absolute local path. The description adds no syntax, format, or size constraints on top of this, so the baseline 3 for high schema coverage is appropriate.

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

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

The description states a specific verb+resource: it creates a recipe from a zip archive, and the endpoint path [POST /api/recipes/create/zip] reinforces that. It implicitly distinguishes itself from sibling creators like create_recipe_from_html_or_json and create_recipe_from_image by naming the zip/archive input, though it never explicitly contrasts 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 when-to-use guidance. The description never says when to prefer this over create_recipe_from_html_or_json, create_recipe_from_image, or recipe_crud_create_one, nor any prerequisite (e.g., archive must exist locally, auth required). The keyword list ('add recipe, new recipe...') is retrieval bait, not usage guidance.

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

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

With no annotations, the description carries the full behavioral burden, and it only implies permanence via 'Delete ... from the Database'. It omits whether the deletion is reversible, what auth/permissions are required, whether the token's sessions are immediately invalidated, and what the response looks like. The 'write api token' keyword also muddies the destructive nature of the 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?

The core sentence is front-loaded, but it is buried under a repetitive SEO keyword dump ('delete_api_token, delete api token, remove api token, destroy api token, write api token...') that includes an unrelated term ('mealie') and restates the tool name many times.

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 destructive mutation with no annotations, no output schema, and an undocumented parameter, the definition should disclose auth requirements, irreversibility, and side effects. None of that is present, leaving the agent without the information needed to call this 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 coverage is 0% and the single parameter 'token_id' is undocumented in both schema and description. The endpoint template at least reveals that token_id is a path parameter identifying the target token, which is marginal added meaning, but format, source, or acquisition of the ID is never 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 ('Delete api token') and even pins the exact endpoint (DELETE /api/users/api-tokens/{token_id}), so the agent knows precisely what the call does. It does not, however, distinguish itself from siblings like create_api_token or get_token, leaving that differentiation to the reader.

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 mention of alternatives (e.g., refresh_token vs delete_api_token), and no prerequisites or warnings about irreversible token revocation. The keyword list adds noise rather than usage context.

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

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

No annotations are provided, so the description carries the full burden. It never states that the operation is destructive and irreversible, whether it requires authentication, or what happens to IDs that do not exist. Only the literal word 'delete' hints at the mutation, which is thin for a no-annotation 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?

The core purpose is front-loaded, but the body is padded with an undifferentiated keyword dump ('delete_many, delete many, ... mealie') that adds no decision-relevant information and pushes the useful content to a single bare sentence.

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 at 0% coverage, the definition leaves the agent without the destructive-behavior and input-format information needed to call this mutation correctly. The keyword block substitutes volume for substance.

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 'ids' has 0% schema description coverage, and the description never mentions it or explains that a list of UUIDs is required. 'Delete Many' hints at plural input, but the field name, format, and required count are 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 verb (delete) and resource (household shopping list items) and the HTTP path confirms scope, so the agent can identify the target resource. However, 'Delete Many' and 'Delete shopping item' (singular) are inconsistent in number, and the description never distinguishes itself from the sibling delete_one other than by the auto-generated name.

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

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

There is no statement of when to use bulk deletion versus households_shopping_list_items_delete_one, and no prerequisites or exclusions. Usage is only implied by the tool name and the endpoint path.

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 never states that this is destructive/irreversible, whether it requires ownership or permissions, what happens if no image exists, or what is returned. The only behavioral signal is the DELETE verb embedded in the path, which is already implied by the tool name.

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

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

The operative content ("Delete Recipe Image … Delete image … [DELETE /api/recipes/{slug}/image]") is front-loaded and clear, but the long keyword dump ("destroy image, write image, delete, remove, destroy, write, mealie…") is filler that adds no semantic value and bloats the definition.

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 destructive, single-parameter mutation with no annotations and no output schema, the description should at minimum disclose irreversibility, required permissions, and the target of deletion. None of that is present, leaving an agent unable to judge consequences of the call.

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

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

Schema coverage is 0% (the single `slug` parameter has no description), but the description partially compensates by embedding {slug} in the endpoint path, showing it identifies the recipe. It adds no format, uniqueness, or lookup semantics beyond that placement.

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 ("Delete Recipe Image", "Delete image") and even gives the endpoint DELETE /api/recipes/{slug}/image, so an agent knows exactly what operation this performs. It does not, however, contrast itself with adjacent siblings like update_recipe_image, upload_recipe_asset, or get_recipe_img, so the differentiation is left to inference.

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

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

There is no when-to-use or when-not-to-use guidance, no mention of alternatives, and no prerequisites. The HTTP verb and path imply it removes an existing image, but nothing tells the agent under what circumstances to reach for this versus replacing the image.

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 disclose real behavioral detail: the tag is removed from the database and detached from any recipes containing it, with no impact to the recipes themselves. It omits whether deletion is irreversible, what permissions are required, and what the response returns, which matters for a destructive 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?

The core message is front-loaded, but the header repeats the tool name and category, and the trailing 'Keywords:' block is a long keyword-stuffing list that adds no selection value. Roughly half the text is noise.

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 exists, and since this is a one-parameter destructive tool, the description is minimally adequate: it explains the cascade effect on recipes. It still leaves irreversibility, auth requirements, and error behavior (not-found tag) unstated.

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 the single required item_id parameter, and the description adds almost nothing beyond the endpoint path showing {item_id}. It never explains that item_id is the tag's UUID, how to obtain it, or what happens on an unknown ID.

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 ('Delete a recipe tag', 'Removes a recipe tag from the database') and even includes the endpoint. However, it does not explicitly distinguish itself from sibling tag operations such as organizer_tags_update_one or bulk tag tools, 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?

There is no when-to-use guidance or reference to alternatives (e.g., bulk operations, organizer_tags_get_all for discovering tag IDs first). The only conditional statement is about side effects ('does not impact a recipe'), not about when this tool is the right choice.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not say what happens when 'name' is omitted (is the original name copied? suffixed?), whether the duplicate is independent of the source, what permissions are required, or what the response contains for a creation-style 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?

The core statement and endpoint path are front-loaded and useful, but the long trailing keyword list is low-value padding that repeats variants like 'duplicate, create, add, new, make, write' and adds noise rather 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?

For a mutation tool with no annotations, no output schema, and 0% documented parameters, the description should say more about the resulting duplicate and the effect on existing data. As written, an agent can construct the call but cannot predict its outcome.

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%, with two required params. The description explains the optional body.name ('a new custom name if given'), but says nothing about the slug parameter's format or that it identifies the source recipe to copy. Partial compensation 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 ('Duplicate recipe') and even gives the concrete endpoint POST /api/recipes/{slug}/duplicate, so the agent knows exactly what the tool does. It is partially undermined by a keyword block that also advertises 'create recipe, add recipe, new recipe, make recipe', which blurs the line with recipe_crud_create_one.

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 use case is implied: copy an existing recipe (given by slug), optionally renaming it. There is no explicit guidance on when to prefer this over recipe_crud_create_one, or any precondition such as the slug needing to already exist. The keyword line actively muddies alternative selection rather than clarifying it.

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

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

No annotations are provided, so the description carries the full behavioral burden. It states nothing about side effects (does it send an actual email?), required permissions, idempotency, or rate limits. The POST endpoint implies a mutation, but the description doesn't disclose what it creates or what happens on success/failure.

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 bloated with a redundant keyword dump that repeats generic verbs (create, add, new, make, write) and the tool name. The meaningful information ('Create email', POST path) is buried in boilerplate. No useful structure.

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

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

For a mutation tool with no annotations, no output schema, and a nested required body at 0% schema coverage, the description is completely inadequate. An agent cannot determine what this tool actually does, what the token represents, or how it relates to invite tokens.

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 there is 1 required parameter ('body') which itself contains required 'email' and 'token' subfields. The description provides no explanation of the body structure, the meaning of 'token' (is it an invite token? an auth token?), or the email format required.

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

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

The description says 'Create email' but the tool is named email_invitation and the path is /api/households/invitations/email. It's ambiguous whether this creates an email invitation for a household or sends an email. The keyword soup ('email, households invitations, create, add, new, make, write') restates the title rather than clarifying the operation.

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

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

No guidance on when to use this tool. With siblings like create_invite_token and send_invitation, the description doesn't explain which to use or in what sequence. The keyword list provides no contextual routing.

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 nothing: no read-only confirmation beyond keyword spam, no pagination or ordering behavior despite pagination params, and no note that group_slug is required. A 9-parameter read tool with zero behavioral disclosure is 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 two substantive sentences are front-loaded and fine, but they are buried under a large keyword-stuffed block that adds length without information. The keyword tail is pure noise that dilutes the usable 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 9-parameter, group-scoped list endpoint with no annotations and no output schema, the description leaves everything an agent needs unstated: required group_slug, pagination defaults, filtering/sorting semantics, and the read-only nature. It is not complete enough to invoke the tool correctly without opening the schema and guessing.

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 9 parameters, and the description supplies no meaning for any of them — not page, perPage, search, orderBy, queryFilter, orderDirection, paginationSeed, or orderByNullPosition. The one required parameter is only visible in the schema, and even that lacks explanation.

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 ('List categories') and gives the endpoint path, so the basic purpose is recoverable. However, it does nothing to distinguish itself from near-identical siblings such as organizer_categories_get_all, organizer_categories_get_one, or explore_categories_get_one — the group-scoped nature implied by the path is never spelled out.

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 the many sibling category endpoints (organizer_categories_get_all, explore_categories_get_one, etc.), nor any prerequisites such as needing a valid group_slug or read permissions. The trailing keyword list is a bag of synonyms, not guidance.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it offers only the bare keyword "read-only". It says nothing about permissions, scoping to group/recipe ownership, error behavior for missing items, or response shape.

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 bulk of the text is SEO keyword stuffing that duplicates the tool name and synonyms, burying the single meaningful fact (the endpoint path). Structure is poor and front-loading is wasted on a near-tautology.

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

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

For a two-parameter retrieval tool with no annotations and no output schema, an agent needs at least param meaning and any scoping/auth notes, none of which are supplied. The description is insufficient to call the tool correctly beyond guessing from the path.

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 both required parameters (item_id, group_slug) are undocumented anywhere. The URL template [GET /api/explore/groups/{group_slug}/organizers/categories/{item_id}] loosely implies group_slug scopes to a group and item_id identifies the category, but neither format (uuid4) nor constraints are 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?

"Get One — Explore: Categories. Get category" essentially restates the tool name without adding a distinct verb+resource statement beyond what the name already conveys. It does not differentiate this from the many sibling getters such as explore_categories_get_all, organizer_categories_get_one, or organizer_categories_get_one_by_slug.

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 indication of when to use this tool versus the closely related explore_categories_get_all or the slug-based organizer_categories_get_one_by_slug. The keyword list merely repeats synonyms (fetch, read, retrieve) without any conditional routing 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. It states 'read-only' as a keyword and implies a GET request, but does not explain pagination behavior, response shape, rate limits, or authorization requirements for the group_slug. For a 9-parameter list 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?

The description is dominated by a keyword dump of 28+ near-duplicate search terms that add no semantic value. The actual operational description is a single terse sentence. The structure is poorly front-loaded, wasting space on keyword noise rather than useful context.

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

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

For a tool with 9 parameters, 0% schema coverage, no annotations, and no output schema, the description is completely inadequate. It doesn't explain any parameter, the response format, pagination, or how it relates to sibling tools. An agent could not reliably invoke this tool correctly based on this definition.

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

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

Schema description coverage is 0% and the description adds no parameter meaning whatsoever. Nine parameters exist (page, search, orderBy, perPage, group_slug, queryFilter, orderDirection, paginationSeed, orderByNullPosition) with no explanation of their purpose, format, or constraints beyond their titles.

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 (list cookbooks) and includes the HTTP endpoint, so the agent knows exactly what the operation is. It doesn't explicitly differentiate itself from the sibling explore_cookbooks_get_one or households_cookbooks_get_all, but the 'list' verb and plural resource make the distinction reasonably inferable.

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 explore_cookbooks_get_one, households_cookbooks_get_all, or the households cookbook CRUD tools. There is no mention of prerequisites, pagination behavior, or when-not conditions. The keyword dump provides search terms but no actual usage context.

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

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

No annotations are provided, so the description carries the full burden. It conveys only that this is a read ('get', keyword 'read-only') and the URL pattern; it says nothing about permissions, whether the caller must belong to the group, error behavior on missing IDs, or what the response 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?

The purpose is front-loaded, which is good, but the remainder is a long keyword-stuffing block that repeats 'get cookbook / fetch / read / retrieve / view / show' with no additional information. Every sentence after the first fails to earn its place.

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

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

For a two-parameter read tool with no annotations and no output schema, the description should at least explain the return value or any scoping constraints. It leaves both entirely uncovered, so an agent has only the name and URL template to work with.

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 two required parameters (item_id, group_slug). The description's embedded URL template does show where each value is substituted, which is a small hint, but it adds no meaning about formats, UUID vs slug expectations, or what group_slug identifies.

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 ('Get cookbook') plus the concrete REST path, so the agent knows exactly what entity is fetched. It is clear, but it does not differentiate itself from the very similar sibling households_cookbooks_get_one, which fetches the same entity type under a different scope.

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

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

There is no statement of when to use this tool versus alternatives, no prerequisites, and no exclusions. The long keyword list repeats synonyms of 'get' rather than giving any selection guidance, so the agent must 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 behavioral burden, and it says almost nothing: the 'read-only' keyword hints at a safe read, but pagination behavior, default ordering (orderDirection defaults to 'desc'), permission requirements, and result shape are never disclosed. For a paginated listing endpoint 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 front-loaded first clause is fine, but the body is dominated by a ~50-term keyword dump that repeats the tool name and its sub-words. That bulk adds no information an agent can act on and obscures the single useful detail (the endpoint).

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 9-parameter paginated list tool with no annotations and no output schema needs more than a title and a URL. Nothing explains pagination mechanics, ordering defaults, search semantics, or what a food record contains, so an agent cannot invoke or interpret this 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?

Schema description coverage is 0% across 9 parameters, so the description must compensate and does not. Only group_slug is indirectly conveyed through the URL path template; page, perPage, search, orderBy, queryFilter, paginationSeed, orderDirection, and orderByNullPosition are entirely undocumented anywhere. The 'search/find' keywords refer to the tool name, not the search 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 verb+resource ('List foods') and shows the backing endpoint GET /api/explore/groups/{group_slug}/foods, so the basic purpose is clear. However, 'Explore: Foods' is largely a restatement of the tool name, and it never distinguishes this from close siblings like recipes_foods_get_all or explore_foods_get_one. The trailing keyword block is name-variant filler, not a statement of scope.

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

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

There is no when-to-use or when-not-to-use guidance and no named alternative. The agent is left to infer from the URL path that this is a group-scoped explore listing versus the group-level recipes_foods_get_all. The keyword list ('search food', 'browse foods') is alias padding, not usage direction.

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

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

No annotations are provided, so the description carries the full burden. It does not state whether the operation is read-only, how authentication works, whether the response is paginated, what errors may occur, or what a food object contains. The keyword 'read-only' appears in the keyword list, but that is a weak disclosure and not backed by annotations. For a get-one operation with zero annotation coverage, more behavioral context is needed.

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 bloated with a long list of keywords and synonyms that repeat the same concepts (food, foods, get, fetch, read, retrieve, view, show). The core message is front-loaded but buried under noise. This is not concise; the keyword list adds no value for an agent.

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

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

Given no annotations, no output schema, 0% parameter description coverage, and two required parameters, the description is incomplete. It omits authentication requirements, response shape, error handling, and differentiation from sibling tools. An agent would struggle to call this tool correctly without additional context.

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

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

Schema description coverage is 0%, and the description provides no explanation of the two required parameters (item_id and group_slug). While the URL path hints at their roles, there is no added meaning about formats, constraints, or expected values. The description fails to compensate for the low schema coverage.

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

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

The description states 'Get food' with an HTTP endpoint (GET /api/explore/groups/{group_slug}/foods/{item_id}), making the verb and resource inferable. However, it does not distinguish this tool from sibling recipes_foods_get_one, which appears to retrieve a food item through a different route. The purpose is vague beyond the generic 'get one' phrasing.

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

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

There is no explicit guidance on when to use this tool versus alternatives like recipes_foods_get_one, explore_foods_get_all, or other get-one tools. The keyword list is a dump of synonyms and not actionable usage guidance. The agent is left 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?

With no annotations, the description carries the full burden. It offers only the keyword 'read-only' as a safety signal but says nothing about pagination behavior (despite page/perPage/paginationSeed params), auth requirements, or what the response contains for a list 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?

The purpose and endpoint are correctly front-loaded in the first two lines, but the bulk of the description is a bloated keyword dump repeating trivial morphological variants ('list household, list households, get household...'). That padding adds noise rather than value.

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, 0%-documented, annotation-free list tool with no output schema, the description is far too thin. It neither explains the filtering/sorting/pagination parameters nor clarifies its relationship to the many sibling household tools.

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

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

Schema description coverage is 0% across 8 parameters, so the description must compensate and largely does not. The endpoint path hints that group_slug is required and path-based, but orderBy, orderDirection, queryFilter, paginationSeed, page, and perPage are left 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 and resource ('List households') and even gives the HTTP endpoint, so the operation is unambiguous. However, it does nothing to distinguish itself from the near-identical sibling 'get_all_households' (and 'get_one_household'), so it falls short of full 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?

There is no when-to-use or when-not-to-use guidance, and no mention of alternatives despite several overlapping household-listing siblings. The keyword block restates synonyms but provides no selection logic, and the endpoint only implies that a group_slug is required.

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 safety via a bare 'read-only' keyword. It says nothing about pagination behavior, permission requirements, result caps, or what the group scope actually restricts, which is a large gap for a 19-parameter listing tool.

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

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

The core purpose is front-loaded in one short sentence, but that sentence is then buried under a long keyword-stuffing block that adds no informational value and inflates the definition. Roughly half the text is SEO noise rather than content that 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?

A 19-parameter, filter-heavy listing tool with no annotations, no output schema, and 0% parameter documentation is left almost entirely undescribed. An agent has no basis to know how to filter, sort, or page results correctly, so the definition is inadequate for the tool's 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 0% across 19 parameters, and the description supplies almost no compensating meaning. Only group_slug is inferable from the endpoint path; the many filters (tags, foods, tools, households, requireAll*, orderBy, paginationSeed, etc.) are entirely unexplained in both schema and 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 states a specific verb and resource ('List recipes') and the endpoint path reveals the group-scoped explore surface. However, it does nothing to distinguish this from close siblings like recipe_crud_get_all, explore_recipes_suggest_recipes, or shared_recipes_get_all, so the agent gets a clear purpose but no routing signal.

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 exclusions, and no mention of alternatives. The trailing keyword list ('list recipe, get recipe, search recipe...') is synonym spam, not usage guidance, so nothing tells the agent when to prefer this over recipe_crud_get_all or the suggest-recipes sibling.

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

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

Annotations are absent, so the description carries the full burden and it fails. It never says this is a read-only operation, never explains that results must be scoped to a group_slug, never mentions whether results are ranked or personalized, and gives no pagination or result-size context despite an explicit limit/paginationSeed pair.

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?

Severely bloated: the bulk of the text is an alphabetical synonym flood (list/post/g/l/i/k) that would have been better replaced by one real sentence, while a raw URL path is front-loaded as if it were user-facing documentation.

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

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

For a 13-parameter, no-annotation, no-output-schema tool, the description omits required group_slug semantics, the food/tool matching model, the missing-count thresholds, ordering, and result shape. It cannot be called correctly from this definition alone.

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

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

13 parameters with 0% schema description coverage, and the description mentions none of them. Ten of them (foods, tools, maxMissingFoods, maxMissingTools, includeFoodsOnHand, includeToolsOnHand, orderBy, orderDirection, orderByNullPosition, paginationSeed, queryFilter) are bare titles in the schema with no meaning attached anywhere, so an agent has no basis for setting the suggestion-ranking knobs.

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 meaningful content is 'Suggest Recipes — Explore: Recipes. List suggestions' plus a raw REST path. That restates the name rather than stating what a 'suggestion' is or how it differs from the siblings recipe_crud_suggest_recipes and explore_recipes_get_all. The keyword tail then lists generic synonyms (list, get, search, find) that add no discriminating information.

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 at all, and no mention of the two obvious alternatives for the same job: recipe_crud_suggest_recipes and explore_recipes_get_all. The synonym dump actually encourages wrong selection by implying the tool is a generic search/find endpoint.

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 delivers almost nothing: the only hint is the keyword 'read-only' and the GET path. It never explains pagination behavior despite page/perPage/paginationSeed parameters, nor authorization needs for the group_slug scoping.

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 first two sentences are appropriately front-loaded and compact, but they are followed by a long comma-separated keyword dump that repeats 'tag/tags', 'explore', and every verb synonym. That block adds no information and roughly triples the definition's length.

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

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

For a 9-parameter, group-scoped listing endpoint with no annotations and no output schema, the description omits pagination semantics, result shape, and parameter meanings. The endpoint URL is the only genuinely useful addition, leaving the definition materially incomplete.

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

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

Schema description coverage is 0% across 9 parameters, so the description is obligated to compensate and instead says nothing about any of them. Fields like search, queryFilter, orderBy, paginationSeed, and orderByNullPosition remain semantically opaque beyond their bare names.

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

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

The opening 'Get All — Explore: Tags. List tags.' states a clear verb (list) and resource (tags), reinforced by the concrete endpoint path GET /api/explore/groups/{group_slug}/organizers/tags. However, it does nothing to distinguish this from the very similar sibling organizer_tags_get_all or explore_tags_get_one, so the agent must guess which list endpoint to pick.

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 organizer_tags_get_all, explore_tags_get_one, or get_empty_tags. The keyword block contains verbs like 'search tag', 'find tag', 'browse tag' that are synonym stuffing rather than routing guidance, so the agent gets no real selection criteria.

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

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

No annotations are provided, so the description carries the full burden, and it discloses almost nothing: the "read-only" keyword hints at a safe read, but there is no mention of auth/permission requirements, error behavior, or what the endpoint returns. For a 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?

The definition is dominated by a long comma-separated keyword list ("explore_tags_get_one, explore tags get one, get tag, fetch tag...") that adds no retrievable meaning. The actual purpose statement is one redundant fragment, so the payload is noise-heavy rather than front-loaded.

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

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

With two required parameters, no output schema, and no annotations, the description should explain input format and return expectations. It instead repeats the title and lists keywords, leaving an agent unable to confidently construct a correct call.

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

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

Schema description coverage is 0% and neither parameter is documented in the description. The endpoint template shows group_slug and item_id in their path positions, which faintly implies a group scope and a UUID identifier, but this does not compensate for the total absence of parameter 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 states a recognizable verb+resource ("Get tag") and the endpoint path clarifies the resource lives under groups/{group_slug}/organizers/tags. However it does nothing to distinguish this from the many sibling retrievers such as organizer_tags_get_one, organizer_tags_get_one_by_slug, or explore_tags_get_all, and the surrounding text is a keyword dump rather than a definition.

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 the near-identical organizer_tags_get_one or the by-slug variant. The only contextual token is "read-only", which names a property but not a usage condition. The agent is left to infer the selection 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 burden. It offers only the single keyword 'read-only' buried in the keyword list, and gives no information about pagination behavior, scoping (group_slug required), or return shape for a list endpoint with 9 parameters.

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

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

The opening sentences are compact, but they are immediately followed by a long, redundant keyword list ('list tool, list tools, get tool, get tools, search tool, search tools...') that adds no discriminating information. The bulk of the description is filler rather than front-loaded value.

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 9 parameters, no annotations, no output schema, and 0% schema coverage, the description is grossly incomplete. An agent has no way to know required vs optional parameters, pagination defaults, or filtering behavior from the text.

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 9 parameters, and the description provides essentially no parameter semantics. The endpoint path hints that group_slug is a path variable, but nothing explains page, perPage, search, orderBy, queryFilter, or the ordering enums. The description does not 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 recognizable verb+resource ('List tools' for Explore) and includes the endpoint path, so the basic operation is inferable. However, it does not distinguish this from the many sibling tools (organizer_tools_get_all, explore_tools_get_one, organizer_tools_get_all), and 'tools' as a resource is ambiguous. Purpose is only minimally clear.

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

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

There is no guidance on when to use this tool versus organizer_tools_get_all or explore_tools_get_one. The only content beyond the operation is an undifferentiated keyword dump (list/get/search/find/browse/fetch/read) that repeats the same concept rather than informing 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?

No annotations are provided, so the description must carry the full behavioral burden. It only supplies a 'read-only' keyword and the GET endpoint, but does not address authentication, permissions, error conditions, or whether the response includes related resources.

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 first two clauses are efficient, but the trailing 'Keywords:' list is a long, redundant synonym dump that repeats the tool name and generic verbs. This keyword stuffing harms conciseness and pushes useful information behind noise.

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

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

For a two-parameter GET tool with no output schema and no annotations, the definition should at least clarify parameter roles or usage context. The endpoint adds some structure, but missing parameter semantics and sibling differentiation leave the definition incomplete for reliable selection.

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 needs to compensate. It shows a URL template with {group_slug} and {item_id}, which indicates both are path parameters, but it never explains what a group_slug identifies or what kind of UUID item_id must be.

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 and resource ('Get tool') and the endpoint pins it to the Explore namespace, which helps separate it from organizer_tools_get_one. However, it does not explain how Explore differs from Organizer or when each namespace applies, so sibling differentiation is only implicit.

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 is provided. The tool is simply described as 'Get tool' with an endpoint, and the keyword list repeats synonyms without saying when to choose it over organizer_tools_get_one or explore_tools_get_all.

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 for a read of group settings. It doesn't state whether this is read-only, what it returns, whether it requires group-admin privileges, or what happens on missing settings. The 'read-only' keyword is buried in synonym spam rather than stated as a behavioral guarantee.

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 mostly a keyword dump: ~30 synonyms for 'get setting' and 'list settings' followed by route and group keywords. None of it is front-loadable information; the single useful token (the GET route) is buried after the redundancy. Every synonym sentence is 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?

No output schema exists, so the description should hint at the return shape (a settings object for the group's AI provider configuration), but it says only 'List settings'. Combined with no annotations, no permissions note, and no sibling differentiation, an agent lacks what it needs to call this correctly among the many AI-provider and group tools.

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

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

Parameter count is 0, and the schema is empty with additionalProperties:false. Baseline for zero parameters is 4; there is nothing for the description to disambiguate, and it does not mislead about inputs. The keyword soup doesn't help but doesn't hurt parameter 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 wraps the tool name in a title and then repeats 'List settings' plus a keyword soup. The only substantive content is 'GET /api/groups/ai-providers/settings', which gives a resource path but no meaningful statement of what the tool returns or why an agent would call it over siblings like groups_ai_providers_get_ai_provider. The 30+ 'Keywords:' synonyms are tautological restatements, which is exactly the tautology pattern.

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, when-not-to-use, or alternative tool is named. The sibling list contains groups_ai_providers_get_ai_provider, update_ai_provider_settings, and other AI-provider tools that an agent must distinguish from this one, and the description provides zero routing guidance. The keyword spam ('search', 'find', 'browse') actively implies capabilities that aren't relevant to a settings GET.

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

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

No annotations are provided, so the description must carry behavioral disclosure. It reveals the GET endpoint and the return set (categories without recipes), which implies a read-only operation, but it omits auth requirements, pagination, and response format details.

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 core purpose is front-loaded, but the long keyword list is redundant stuffing that does not earn its place. It bloats the description without adding useful 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 zero-parameter read-only list tool, the description covers the basic purpose and return type. However, with no annotations and no output schema, it should provide more context about auth, pagination, or how it relates to sibling category-listing tools.

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

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

The tool takes zero parameters, so the schema description coverage is 100% by default. Baseline for no parameters is 4, and there is no parameter semantics to clarify further.

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: list categories that do not contain any recipes, and gives the endpoint. It differentiates from the broader organizer_categories_get_all by the 'empty' condition, but does not name that sibling or explicitly contrast with it.

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 empty-category condition implies when to use it, but there is no explicit guidance on alternatives such as organizer_categories_get_all or get_empty_tags, nor any when-not-to-use conditions. Usage is left to inference.

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

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

With no annotations, the description carries the full behavioral burden. It implies a read via the GET endpoint, but says nothing about pagination behavior, default ordering, authentication requirements, or what the response contains — notable gaps for a tool with seven pagination/ordering parameters.

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

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

The useful content is front-loaded into two short fragments, but the bulk of the description is a bloated comma-separated keyword list that restates the name many times and adds no invocation value. Large portions do not earn their place.

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

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

For a paginated list tool with seven undocumented parameters, no output schema, and no annotations, the description is far too thin. It never explains paging, ordering, or filtering, leaving the agent unable to use the parameters 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% across seven parameters (page, orderBy, perPage, queryFilter, orderDirection, paginationSeed, orderByNullPosition). The description mentions none of them, so an agent gets no meaning for pagination, filtering, or ordering semantics from either the schema or 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?

States a clear verb+resource ('List households') and gives the underlying endpoint (GET /api/groups/households), so the agent knows exactly what operation this is. However, it offers no differentiation from nearby siblings like get_household, get_one_household, or explore_households_get_all, which leaves ambiguity about which household-list variant to pick.

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 or when-not-to-use guidance and no mention of alternatives, only a keyword dump of synonyms for 'list households'. The agent gets no signal about choosing this over the other household-listing 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. It implies a read via 'Get' and the 'read-only' keyword, and notes it returns 'current theme settings', but says nothing about auth requirements, what the theme object contains, or caching/rate 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 genuine content is one short sentence, but it is buried under an endpoint tag, a duplicated sentence, and a long keyword dump that adds no selection signal. Poorly front-loaded relative to its useful payload.

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-argument read tool this is minimally sufficient to invoke, but with no output schema and no annotations the description never explains what the returned theme settings look like, leaving a real gap for the agent interpreting the result.

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 clarify; the baseline is 4. Schema coverage is effectively complete by vacuity.

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 ('Get theme' / 'Get's the current theme settings') and scopes it to the About app, so an agent can tell it apart from app_about_get_app_info. It is clear but marred by redundant restatement and keyword padding rather than precise framing.

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, and no mention of alternatives (e.g., update theme or app info tools). The agent must infer usage purely from the name.

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

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

With no annotations provided, the description carries the full burden. It does disclose the core behavior (returns only tags with zero attached recipes) and the underlying endpoint, and the keyword list signals 'read-only'. However it omits pagination, sort order, authentication requirements, and the shape of returned items, which is a meaningful gap for an unannotated tool.

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

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

The useful content is one sentence, front-loaded before the noise, but roughly two-thirds of the description is SEO keyword stuffing ('get tag, get tags, search tag, search tags, find tag... mealie'). Those tokens add no selection or invocation value and dilute the definition.

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

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

For a no-parameter read tool with no output schema, the description conveys what the endpoint returns and the filter applied. It is adequate but does not describe pagination, ordering, or response structure, which an agent would need for a reliably-formed call.

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

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

The tool takes zero parameters and the schema is empty with additionalProperties=false, so there are no parameter semantics to explain. Baseline 4 applies; nothing in the description misleads about inputs.

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, and crucially a scoping constraint: 'Returns a list of tags that do not contain any recipes.' That distinguishes it from sibling list tools such as organizer_tags_get_all and explore_tags_get_all. It never names those siblings explicitly, 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?

There is no guidance on when to call this versus organizer_tags_get_all or explore_tags_get_all. The 'empty' qualifier implies the use case but the description never states when an agent should prefer this over the general tag listing tools, nor any prerequisites.

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

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

No annotations are provided, so the description carries the full burden, and it discloses almost nothing: no pagination, no permission requirements, no return shape, no error behavior. The lone 'read-only' token buried in the keyword soup is the only behavioral 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?

The first two lines are reasonably front-loaded, but the definition is padded with an enormous redundant keyword list ('get favorite, list favorite, search favorite… read-only, mealie') that repeats the same concept a dozen times without adding 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 tool with no annotations and no output schema, the agent lacks any signal about what comes back, whether results are paginated or scoped to permissions, or how to interpret them. The description should do more than restate the endpoint.

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

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

Schema description coverage is 0% and the sole 'id' parameter is undocumented in the schema. The route template [GET /api/users/{id}/favorites] does implicitly tell the agent the id is a user id, which is real added value, but the format (uuid4) and constraints come only from the schema.

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

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

The description states a specific verb and resource: 'Get user's favorited recipes,' reinforced by the route [GET /api/users/{id}/favorites]. It is distinguishable from the sibling get_logged_in_user_favorites because it takes an explicit user id, though the description never makes that distinction explicit.

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

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

There is no guidance on when to use this versus get_logged_in_user_favorites, add_favorite/remove_favorite, or get_ratings. The keyword list mentions 'users ratings' and 'read-only' but that is retrieval bait, not usage direction.

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

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

No annotations are provided, so the description carries the burden. It does disclose the HTTP method (GET) and that it returns a single user, implying a read-only operation, but says nothing about auth/permission requirements, error cases when the member does not exist, or response shape.

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 core sentence is fine and front-loaded, but the trailing 'Keywords:' list is pure noise, restating the name and synonyms ('get, fetch, read, retrieve, view, show') that add no selection value.

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

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

For a simple single-param read tool with no output schema this is roughly adequate, but it omits parameter format details and the distinction from sibling list tools, leaving meaningful gaps.

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

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

Schema description coverage is 0% for the single required parameter. The description adds nothing about username_or_id — it does not explain that it accepts either a plain username string or a uuid4, nor any format/example guidance, so it 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?

States a specific verb and resource ('Get member') and clarifies scope with 'Returns a single user belonging to the current group.' However, it does not distinguish itself from the plural sibling get_group_members or get_household_members, so an agent must guess which is appropriate.

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 get_group_members (all members) or get_household_members. The 'Self Service' tag hints at context but no condition or alternative is 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. It implies a read of the current group's members but never states pagination behavior, auth/scope requirements, or the return shape, which matters for a 7-parameter listing endpoint.

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

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

The useful content is two short clauses; the rest is a ~40-term keyword dump ('list member, list members, search member...') that adds no meaning. Purpose is front-loaded, but the bulk is noise.

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 paginated list tool with 7 undocumented params, no annotations, and no output schema, the description omits pagination/ordering guidance and any scoping caveats. An agent could call it, but not 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 description coverage is 0% across 7 parameters (page, perPage, orderBy, queryFilter, etc.), and the description says nothing about pagination, ordering, or filtering semantics. This is the case where the description must compensate and it does not.

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

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

The description states a specific verb+resource ('List members') and adds the endpoint and scope ('Returns all users belonging to the current group'). It does not, however, distinguish itself from the near-identical sibling get_group_member or get_household_members, leaving the agent to guess which member-list tool applies.

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, and no naming of alternatives. 'Groups: Self Service' reads as a category tag rather than a usage condition, so the agent gets no routing signal versus get_group_member or get_household_members.

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 implies a read-only list operation ('List preferences') but says nothing about authentication/permissions, the scope of the group context, what preferences are returned, or format, so a substantial gap remains for an unannotated tool.

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

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

The useful content is one short line ('List preferences'), which is front-loaded, but the bulk of the description is a long, low-signal keyword dump (preference, preferences, list, get, search, find, browse, fetch, read, mealie). This bloats the definition and dilutes the actionable text.

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

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

For a read tool with no output schema, the description should at minimum hint at what 'preferences' are returned, yet it only repeats retrieval synonyms. Combined with the absence of annotations, the definition is too thin for an agent to confidently predict the result or the call's 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 tool takes zero parameters, so there is nothing for the description to disambiguate. Baseline 4 applies: no parameter meaning can be added or omitted when the input schema is an empty object.

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 clear verb (get/list) with a specific resource (group preferences), and the endpoint path [GET /api/groups/preferences] reinforces the intent. However, it gives no differentiation from the very similar sibling get_household_preferences, leaving the agent to infer the distinction between group-level and household-level preferences.

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 alternatives such as get_household_preferences or update_group_preferences. The trailing keyword block lists generic synonyms (get, search, find, browse, read) but these are retrieval-synonym spam, not usage guidance.

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

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

With no annotations, the description carries the full disclosure burden. It implies read-only via the GET verb and the keyword 'read-only', but says nothing about permissions, error behavior, or what a household lookup returns. This is far short of what an unannotated read tool needs.

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 core statement is front-loaded, but the body is dominated by an undifferentiated keyword dump ('get household, fetch household, read household... household, households, explore') that repeats the same concept a dozen times and adds no decision-relevant 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?

There are no annotations, no output schema, and two fully undocumented required parameters, yet the description supplies no return-shape, permission, or usage context. For a tool in a crowded sibling set, this leaves the agent without enough to select or invoke 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?

Schema description coverage is 0% for both required params, so the description must compensate. It only partially does: the path template shows group_slug and household_slug are hierarchical URL path segments, implying a group must be identified before the household. It gives no format, uniqueness, or validation detail for either slug.

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 concrete verb+resource ('Get household') and adds the REST path GET /api/explore/groups/{group_slug}/households/{household_slug}, which clarifies scope better than the bare name. However, it offers zero differentiation from close siblings such as get_one_household, get_all_households, get_household_members, or get_household_preferences, all of which could plausibly match the agent's intent.

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/when-not-to-use guidance and no named alternative. The only routing signal is the namespace prefix 'Explore: Households' inside the description, which is weak given siblings like get_one_household that read as near-identical reads.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It notes the tool returns all users of the current household (a useful scope statement implying read-only), but says nothing about authentication requirements, pagination behavior despite seven paging params, or rate limits. A significant gap for an unannotated tool.

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

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

The core purpose sentence and endpoint are reasonably front-loaded, but the trailing keyword block ('get_household_members, get household members, list member...') is a large volume of redundant filler that does not earn its place.

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

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

For a seven-parameter, zero-coverage, no-output-schema tool, the description is too thin: it does not document paging, ordering, or filtering behavior, and no output schema exists to compensate. An agent can identify the tool but not invoke it richly.

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

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

Schema description coverage is 0% and the description adds no meaning for any of the seven parameters (page, orderBy, perPage, queryFilter, orderDirection, paginationSeed, orderByNullPosition). 'Returns all users' does not explain any of these paging/filtering 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 clear verb (Get/List) and resource (household members), and the phrase 'current household' plus the endpoint [GET /api/households/members] scopes it enough to separate it from siblings like get_group_members or get_all_households. It is specific but does not explicitly contrast itself with 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 articulation of when to use this tool versus alternatives such as get_group_members, get_household, or get_logged_in_user_household. Usage is only implied by the resource name; the keyword list mentions 'search/find/browse' but provides no actual conditions or exclusions.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read (GET /api/households/preferences) but says nothing about auth requirements, what the preferences payload contains, whether pagination applies, or whether results are household-scoped. For a tool with zero annotation coverage this is thin.

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 core statement is front-loaded and short, but roughly two-thirds of the text is a keyword dump (get/list/search/find/browse/fetch/read repetitions) that adds no semantic value and bloats the definition.

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

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

For a zero-parameter read tool with no output schema, the description covers the minimum (what it fetches) but leaves the response shape and scoping unaddressed. Adequate but with clear gaps.

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

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

The tool takes zero parameters, so the baseline is 4; the schema is self-explanatory and there is nothing the description needs to compensate for.

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 ('Get Household Preferences', 'List preferences'), which is clear enough for an agent. However it does not distinguish itself from the sibling update_household_preferences or get_group_preferences / get_logged_in_user_household beyond the resource name, so it stops short of a 5.

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

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

No when-to-use, when-not-to-use, or alternative-tool guidance. The 'Households: Self Service' tag hints at scope but does not tell the agent anything actionable about selecting this tool 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 disclosure burden. It mentions the GET endpoint and household scoping, but says nothing about authentication, error behavior on an unknown slug, or the shape of the returned data; the word 'read-only' appears only as an SEO keyword, not as a behavioral statement.

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 useful content is one short line followed by a long, redundant keyword list ('get household recipe, get recipe, fetch recipe, read recipe, retrieve recipe, view recipe, show recipe...') that repeats the same verb across synonyms without adding meaning. The keyword block consumes most of the text without 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?

With no annotations, no output schema, and 0% parameter description coverage, the description should carry the load, yet it omits return contents, auth requirements, and error conditions. For a fetch tool in a crowded sibling space, this leaves material gaps.

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

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

Schema description coverage is 0% for the single required recipe_slug parameter, and the description does not explain what a slug is, how to obtain one, or how it differs from a recipe id. The URL template {recipe_slug} is the only signal that it is a path parameter.

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

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

The description gives a verb and resource ('Get recipe ... Returns recipe data for the current household') and the URL template shows household scoping via /households/self/recipes/{recipe_slug}. However, 'Get recipe' is a near-tautological restatement of the name, and the description never distinguishes this tool from the numerous sibling recipe-fetch tools it sits beside.

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

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

There is no statement of when to use this tool versus alternatives such as get_recipe, recipe_crud_get_one, or shared_recipes_get_one, despite many plausible siblings. The only hint is the HTTP path, which the agent must interpret on its own.

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 discloses almost nothing: no authorization/permission requirements, no pagination behavior, and no indication of what the response contains. The single '[GET ...]' path and 'read-only' keyword are the only behavioral hints.

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

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

The meaningful content ('List invitations' plus endpoint) is front-loaded, but the bulk of the description is a long comma-separated keyword dump that adds little selection value for an agent. It is bloated without informing invocation.

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 list tool with no output schema, the description is minimally adequate: the agent can call it correctly. However, with no annotations and no output schema, it should describe the return shape or scoping (e.g., whole household), which it does not.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a parameterless tool is 4. No additional meaning 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 states a clear verb+resource ('Get Invite Tokens', 'List invitations') and even includes the backing endpoint [GET /api/households/invitations], so the agent knows this is a read of household invitations. It implicitly distinguishes from siblings like create_invite_token and email_invitation, though it never names them explicitly, keeping it at a 4.

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 mention of alternatives such as create_invite_token (to make a token) or email_invitation (to send one). Usage is only implied by the read-only vocabulary 'list'/'get'.

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

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

No annotations are provided, so the description carries the full burden. It only drops the bare keyword 'read-only' and never states the auth requirement (must be logged in), what fields the profile returns, or error behavior for an unauthenticated call.

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

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

The core phrase 'Get user self' is front-loaded, but the bulk of the text is a keyword dump repeating the same concept in eight phrasings ('get/fetch/read/retrieve/view/show user self') plus generic tokens. That padding does not earn its place.

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

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

For a zero-parameter read tool with no output schema, the description is minimally adequate: it conveys that the current user's own record is returned. It does not describe the returned profile shape or any auth precondition, leaving gaps an agent would prefer filled.

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 the baseline is 4. There are no inputs for the description to clarify, and the schema trivially matches.

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: 'Get user self', backed by the HTTP route [GET /api/users/self]. It is understandable apart from most siblings, though it never explicitly separates itself from update_user or the more specific get_logged_in_user_* variants.

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 or mention of any alternative. With siblings like get_logged_in_user_ratings, get_logged_in_user_favorites, and update_user, the agent gets no help deciding this is the base profile fetch.

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 only that the operation is read-only and names the REST endpoint; auth requirements, pagination, whether 'favorites' are recipes, and return shape are all unstated.

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 first two clauses are adequate, but roughly forty synonym keywords ('list favorite, list favorites, get favorite, get favorites, search favorite...') are tacked on, inflating the text without adding meaning. Signal-to-noise is poor and the useful content is buried.

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 parameterless read tool with no output schema, the endpoint path and read-only framing cover the minimum. However, the absence of any statement about what a favorite actually is or how it differs from get_favorites leaves the definition adequate but incomplete.

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

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

The tool takes zero parameters, so there is nothing for the description to explain beyond the implicit 'self' scoping, which is in fact conveyed by the endpoint path and title. Baseline 4 for a parameterless tool.

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

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

The description gives a specific verb+resource combination: listing the favorites belonging to the authenticated user, plus the concrete endpoint GET /api/users/self/favorites. It is clear but does not differentiate itself from close siblings such as get_favorites, add_favorite, and remove_favorite, which are never mentioned.

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 or when-not-to-use guidance. The 'read-only' keyword hints it is a read operation, but nothing tells the agent why it should choose this over get_favorites or how it relates to add_favorite/remove_favorite.

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 does indicate the operation is a read via the GET endpoint and the 'read-only' keyword, but it says nothing about authentication requirements, scope of returned group data, or error behavior for unauthenticated callers.

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 definition is dominated by a redundant keyword block ('get group self, fetch group self, read group self...') that repeats the same phrase a dozen ways. The genuinely informative content is two short lines buried at the top and bottom.

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

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

For a zero-parameter read tool with no output schema, the description conveys who the data is for (the current user) and where it comes from, which is minimally sufficient. It omits what fields the group data contains and any auth prerequisite, leaving gaps for a tool with no annotations.

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 per the rubric the baseline is 4. The description correctly implies no inputs are needed by describing the call as fetching the current user's own group.

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 ('Get group self', 'Returns the Group Data for the Current User') and pins the exact endpoint [GET /api/groups/self], which separates it from siblings like get_group_members or get_group_preferences. The keyword dump dilutes it, but the core 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 when-to-use guidance is given and no alternative sibling is named. An agent cannot tell from this text whether to prefer this over get_logged_in_user_household or get_group_member for a given need.

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 via the GET route and the 'read-only' keyword, and says it returns household data for the current user. It does not clarify auth requirements, error behavior, or rate limits, which keeps it at a moderate rather than strong disclosure level.

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 core information is front-loaded, but the description is bloated by a long keyword list that repeats synonyms such as 'get household self', 'fetch household self', and the individual verbs 'get, fetch, read, retrieve, view, show'. This keyword stuffing adds noise without decision value and makes the description poorly sized.

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

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

For a zero-parameter, read-only endpoint, the description supplies the route and summarizes the return as 'Household Data for the Current User'. No output schema exists, but the return content is described well enough. Auth is implied by 'Logged In User', though permissions are not explicitly confirmed.

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

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

The tool has zero parameters and 100% schema description coverage on an empty schema. Per the rubric baseline for a 0-parameter tool, a 4 is appropriate. The description adds no parameter meaning because no parameters exist.

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

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

The description states a specific verb and resource: get the household belonging to the logged-in user. The 'self' and 'Current User' framing distinguishes it from siblings such as get_logged_in_user (user profile), get_one_household, and get_all_households (other household scopes). It is clear, though not elegantly phrased.

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 through 'Self Service' and 'Current User', suggesting this is the correct tool when the caller wants the current user's own household. However, it does not explicitly state when to choose it over get_logged_in_user, get_logged_in_user_group, or get_household, nor does it give 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 behavioral burden, and it mostly does not. The embedded 'read-only' keyword and the GET verb imply a safe read, but nothing is said about authentication requirements, 404 behavior when the user has not rated the recipe, or the shape of the returned rating.

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 useful content is a single line at the top; everything after it is a keyword list that repeats the tool name and generic CRUD/HTTP verbs with no informational value. Structure is front-loaded but heavily padded.

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% schema description coverage, the description should compensate for all three, and it does not. An agent knows roughly what it fetches but not what it receives or under what conditions it fails.

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 recipe_id parameter has no description in the schema. The description only exposes it via the path template {recipe_id}, which implies it identifies the recipe but adds no format, source, or lookup guidance beyond that.

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 title restatement plus 'Get rating' and the endpoint [GET /api/users/self/ratings/{recipe_id}] together convey that this fetches the current user's rating for one specific recipe. However, it never distinguishes itself from the very close siblings get_ratings and get_logged_in_user_ratings, so an agent must infer the difference from the name 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 or when-not-to-use guidance at all; the body is a restated title, an HTTP path, and a keyword dump. The agent gets no signal about choosing this over get_ratings (all ratings) or set_rating (write counterpart).

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 reveals the HTTP method implicitly via the endpoint and that the tool is read-only, but says nothing about authentication requirements (the 'self' scope implies a logged-in session), pagination, filtering, or what the response contains. For a listing tool with zero annotation coverage, this is thin.

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 useful content is one short clause plus an endpoint path; the remainder is aggressive keyword stuffing ('rating, ratings, users crud, users, self, list, get, search, find, browse, fetch, read, read-only, mealie'). This bloats the definition and pushes the actual purpose behind noise, so it fails on both brevity and front-loading.

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, no-output-schema read endpoint, the endpoint path and 'read-only' hint are roughly the minimum an agent needs. Missing are the authentication expectation and any statement about response shape or pagination, which would matter for a listing endpoint.

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