CraveUp MCP Server

Official

by craveup-oss

Overview Schema Related Servers Score Discussions

TypeScript

Local

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.6.1
Disambiguation4/5
Most tools cleanly separate by resource and action (auth, locations, menu, orders, billing, mobile). A few naming pairs and composite helpers overlap conceptually, such as get_onboarding_flow vs get_onboarding_status and open_location_for_orders vs the individual settings toggles, but descriptions are generally sufficient to disambiguate.
Naming Consistency5/5
Tool names consistently follow a snake_case verb-first pattern (get_, create_, set_, list_, update_, delete_, start_, complete_, cancel_). 'whoami' is the only stylistic outlier, but it is a recognizable standard command and does not create confusion.
Tool Count2/5
38 tools is well above the 25-tool threshold for feeling appropriately scoped. The server covers a broad restaurant-platform domain, but the set feels heavy and includes composite helpers and meta guides that could be consolidated.
Completeness3/5
Core lifecycles are covered for auth, locations, menu products, and mobile releases. However, order handling ends at fetching active orders, discounts have no update/delete, and subscription management lacks cancellation/update paths, leaving some workflows with dead ends.
Average 4.1/5 across 38 of 38 tools scored. Lowest: 3/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 5 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark the operation as non-read-only, non-destructive, idempotent, and open-world. The description adds limited context by naming the availability states and time scopes, but it does not disclose the important dry-run-first requirement or that confirmToken may be required for destructive/paid/release operations. No contradiction exists, but the description adds only modest behavioral nuance beyond annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler. It is appropriately brief for a simple availability-setting operation, though it is arguably too terse given the important dry-run/apply protocol and six parameters.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The schema provides substantial context through mode, planDigest, and confirmationToken descriptions, and an output schema exists, so the short description is minimally viable. However, the description does not mention the two-phase safety flow, location scoping, or why an agent should select this tool over sibling product-related tools, leaving important contextual gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 50%, so the description should compensate for undocumented parameters. It only elaborates the availability enum in natural language; productId, locationId, and the critical mode/planDigest/confirmationToken flow are left entirely to the schema. The description does not meaningfully add parameter semantics beyond what the schema already exposes.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action and resource: 'Mark a product available or sold out' with temporal options 'today / indefinitely'. This is clear and unlikely to be confused with delete_product or update_product at first glance, though it does not explicitly differentiate itself from those sibling tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 update_product, nor any explanation of the dry-run/apply workflow. The schema hints at the two-phase behavior through 'mode', but the description itself does not tell the agent when to choose this tool or how to safely execute the update.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description says the tool writes to .env, but it omits the central two-phase behavior: the default mode is dry-run and an actual write requires an exact planDigest, with confirmationToken possibly required for certain operations. Because of this omission, an agent may call the tool expecting a write and instead get only a preview.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences front-load the core action and follow with the outcome, with no filler. Every phrase earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with a dry-run/apply workflow, a required planDigest, and a confirmation-token field, the description is too thin to orient an agent. The rich schema partially compensates, but the description does not convey the workflow or the fact that the default mode does not actually write.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents all six parameters. The description adds no parameter-specific meaning beyond what the schema already provides, so the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action and target: writing the public API origin and location ID into an Expo/React Native project .env. This makes the tool's purpose clear and distinguishes it from generic setup tools, though it does not explicitly name alternatives or conditions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The second sentence implies the tool is used when setting up browser and mobile storefronts so they can connect without an API key. However, it never states prerequisites, when to prefer this over other setup tools, or when not to use it, so the guidance is implied rather than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Description claims 'Idempotently create... If the code already exists, returns it without creating a duplicate,' but the idempotentHint annotation is false. This is a direct annotation contradiction, so the score must be 1 regardless of the useful dedup and percentage-cap details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three short sentences, front-loaded with the action. Each sentence contributes a distinct fact: idempotent create behavior, amount constraint, and verification workflow. No filler or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a complex 18-parameter tool with a dry-run/apply mechanism, the description omits the critical mode workflow and confirmation-token requirement. It mentions verification, but an agent cannot safely perform a real apply operation from the description alone.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With only 22% schema coverage, the description needed to compensate for the 18 parameters, but it only adds the amount cap and 'one authorized location.' It fails to explain the dry-run/apply flow, planDigest, confirmationToken, code format, dates, or other required fields.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: 'Idempotently create an order-level promo code at one authorized location.' This clearly distinguishes it from siblings that create locations, list discounts, or update products.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear context: use for creating an order-level promo code at one authorized location, and verify with list_discounts afterward. It doesn't explicitly enumerate when-not-to-use alternatives, but the scope is unambiguous.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover read-only/destructive intent, and the description adds meaningful behavioral context: the address is geocoded server-side when lat/lng are omitted, and a craveup login is required. This goes beyond the structured annotations without contradicting them.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three short sentences, front-loaded with the core purpose, and every sentence adds value. It avoids repetition of schema details and annotations.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 13 parameters, a default dry-run mode, and an apply mode that requires planDigest and possibly confirmationToken. The description omits this two-phase workflow entirely, which is a critical gap for an agent trying to invoke the tool safely and correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 54%, so the description carries partial responsibility for parameter meaning. It usefully explains that lat/lng should be omitted and geocoding will occur, but it leaves the dry-run/apply mode, planDigest, and confirmationToken semantics to the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool updates a location address and provides context about where that address is used (storefront, delivery/pickup). It does not explicitly distinguish this tool from siblings such as create_location or get_location_settings, so it misses the top tier.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives useful context—addresses appear on the storefront and are used for delivery/pickup—and an instruction to omit lat/lng so the server geocodes. However, it does not mention when to prefer this tool over alternatives or provide any exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds an important behavioral detail beyond the annotations: omitted fields keep their current values, indicating a partial update. However, it does not disclose the two-phase dry-run/apply behavior, planDigest requirement, or confirmationToken semantics, which are significant behavioral traits for this 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences with no filler. The core action and field list are front-loaded, and the alternative-tool guidance is compact and actionable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 9 parameters, an output schema, and a non-trivial dry-run/apply flow, yet the description omits the mode/planDigest/confirmationToken process and locationId context. The input schema fills some gaps with field descriptions, but the description alone is not enough to fully guide an agent through the update workflow.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With only 33% schema description coverage, the description partially compensates by listing the editable fields and explaining partial-update semantics. It does not explain mode, planDigest, confirmationToken, productId, or locationId beyond what the schema already states, so the compensation is incomplete.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Change') with a clear resource ('a product') and names the exact editable fields (name, description, price, availability). It distinguishes itself from import_menu for structural changes, but does not differentiate from the sibling set_product_availability, which overlaps on the availability field.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly tells the agent to use import_menu for structural changes (images, modifiers), which provides a clear when-not-to-use condition. However, it does not mention when to prefer this over set_product_availability or explain the dry-run/apply workflow, so the guidance is useful but not fully complete.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already establish that this is destructive, and the description adds a useful non-obvious side effect: category references are cleaned up. It does not explicitly mention the confirmationToken or two-phase dry-run/apply behavior, but those are documented in the input schema and there is no contradiction with the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two short sentences with no filler. The action is front-loaded, and the second sentence adds a meaningful side effect without unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The schema and annotations carry much of the operational burden: destructive intent, dry-run mode, planDigest, confirmationToken, and output schema are all covered. The description supplements this with location scope and category cleanup, leaving only the missing tool-selection guidance as the main gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema descriptions cover mode, planDigest, and confirmationToken (60% coverage), and the description does not repeat those details. It only weakly clarifies location-related context via 'from the location'; productId and locationId remain undocumented, though their names are fairly self-explanatory.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Remove') and resource ('a product') with a location scope, making it immediately clear what the tool does. It also distinguishes itself from siblings like delete_location and update_product by naming the exact target and action.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance about when to use this tool versus alternatives such as update_product, set_product_availability, or delete_location. The dry-run/apply flow appears only in the schema, not as usage guidance in the description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover the read-only, idempotent, non-destructive profile. The description adds valuable behavioral context by specifying the 'menu-editor view' and that modifier group IDs are included, which is not visible from annotations or the schema alone. It does not contradict the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler. Every phrase earns its place, and the most important identifying details are stated immediately.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The core fetch semantics are clear, and the output schema plus annotations cover much of the safety and return-shape context. However, locationId's role is undocumented, and there is no explicit guidance about when not to use this tool, leaving a small but meaningful gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
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. 'By id' clarifies productId, but locationId is left completely unexplained: the agent cannot tell why it exists or when to pass it. With two parameters, half of the parameter semantics are missing.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb and resource: 'Fetch one product (menu-editor view) by id.' It also states the view and included data ('including its modifier group ids'), which distinguishes it from mutation or management siblings like update_product, delete_product, and list_menus.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The use case is implied: call this when you need a single product by its ID and its modifier groups. However, it does not explicitly mention alternatives or exclusion conditions, such as using update_product for modifications, so the guidance is only implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already establish read-only, idempotent, and non-destructive behavior, so the description need not repeat those. It adds meaningful context beyond annotations: results are grouped by customerId, guest checkouts with email now generate a customerId, and authentication is required.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three short sentences, front-loaded with the primary behavior. The guest-checkout note is slightly tangential but still relevant to understanding the customerId grouping, and the login requirement is essential. No wasteful repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only listing tool with an output schema and strongly descriptive annotations, the description is largely complete: it covers scope, grouping, and auth. The main omission is parameter-level detail, but the schema already encodes page/limit constraints and the optional locationId default.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 33%, and the description does not compensate for the undocumented page and limit parameters. It reinforces the locationId concept but says nothing about pagination semantics or how page/limit interact.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with 'Fetch the dashboard Customers page for a location', which is a specific verb plus resource and scope. It further clarifies grouping by Crave customerId, making it easy to distinguish from the many sibling tools that deal with locations, orders, or products.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The tool's purpose is clearly implied, and the 'Requires craveup login' line gives an important precondition. However, the description never explicitly states when to prefer this tool over alternatives or when not to use it, so usage guidance remains mostly implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover read-only, destructive, idempotent, and open-world traits. The description adds valuable behavioral context beyond the annotations by stating that setting at least one method is prerequisite to accepting orders, store hours must be configured beforehand, and authentication is required. This helps the agent understand operational dependencies and consequences.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded: the core purpose and available options appear first, followed by the most important operational constraints. Every sentence earns its place, with no redundant wording or unnecessary background.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Combined with the fully documented input schema and rich annotations, the description provides enough context for an agent to invoke the tool safely: prerequisites, required auth, and the operational effect are clear. The dry-run/apply flow and token requirements are left to the schema, which is acceptable, though a brief prose mention of the dry-run default could have helped agents avoid accidental applies.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already describes all five parameters with detailed descriptions, including the dry-run/apply mechanism, locationId fallback, planDigest requirement, confirmationToken, and fulfillmentMethods behavior. The description adds no new parameter-level semantics beyond listing the same enum values already present in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states that the tool lets you choose how customers order and enumerates the possible methods: takeout, table_side, delivery, room_service. It is easy to infer that this configures fulfillment methods, and the purpose is not misleading. However, it does not explicitly differentiate itself from narrower sibling tools like set_takeout_enabled or set_scheduled_orders_enabled.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides useful context: at least one fulfillment method is required to accept orders, store hours must be set first, and a craveup login is required. It does not, however, explicitly explain when to use this tool versus alternatives such as set_takeout_enabled, nor does it state any exclusions or when-not-to-use conditions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations mark this as non-read-only, idempotent, and non-destructive; the description adds that enabling copies the location main schedule and that login is required. This enriches the behavioral profile beyond the annotations without contradicting them. There is no statement that conflicts with the annotation hints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences; the first delivers the core action and the second adds a critical side effect and auth requirement. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With annotations, schema, and an output schema available, the description fills the remaining gaps: the schedule-copy behavior and the login prerequisite. It doesn't describe the apply/confirmation-token flow, but that is fully covered by the schema. Nothing essential for calling the tool correctly is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema descriptions already cover mode, planDigest, and confirmationToken, leaving 60% of parameters with schema docs. The description doesn't elaborate on locationId or enabled, but their meaning is readily inferable from the schema names and the tool purpose. No additional parameter semantics are provided, so a baseline score is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('Turn takeout on/off') with a clear resource ('for a location'). The name and title align, and the schedule-copy note adds behavioral specificity. Doesn't explicitly compare to sibling tools, but the domain (takeout) is unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the use case: toggling takeout pickup for a location, but doesn't name alternatives like set_scheduled_orders_enabled or open_location_for_orders. It provides a prerequisite (craveup login) and a behavioral caveat (schedule copy on enable), which is useful but stops short of explicit when/when-not guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already establish a mutating but non-destructive and idempotent operation, so the description only needs to add behavioral context. It contributes the authentication requirement via 'Requires craveup login.' It does not contradict any annotation, and 'Set when a location accepts orders' consistently implies a write operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two short sentences with the core action front-loaded and no filler. Every sentence earns its place: one states what the tool does and the other gives preset and authentication context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The input schema is unusually detailed and an output schema exists, so the description can focus on high-level context. It supplies the login requirement and the 7-day custom schedule, but for a 7-parameter workflow it could also mention the dry-run/apply model at the tool level; nevertheless, the schema covers that gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds some parameter-level meaning by explaining that always_open is for dev/demo and that a custom preset requires a 7-day schedule. The input schema already provides substantial descriptions for mode, scope, planDigest, and confirmationToken, so the description does not need to repeat those.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with the active verb 'Set' and defines the resource as 'when a location accepts orders,' which clearly identifies the operation as updating recurring store hours. It does not explicitly distinguish itself from sibling tools like open_location_for_orders or set_scheduled_orders_enabled, but the mention of presets and a weekly schedule conveys the recurring-hours semantics.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives conditional usage guidance: 'Use preset always_open for dev/demo, or pass a custom 7-day schedule,' and it notes the cravingup login prerequisite. However, it does not say when to prefer this tool over the many sibling location and schedule tools, nor does it offer exclusions or alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already establish that this is read-only, idempotent, and non-destructive. The description adds a genuinely useful behavioral/auth detail: the same scoped EXPO_TOKEN used to start the release is required to fetch it. No contradiction with annotations was found.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences: the first states the core action and resource, and the second adds the only essential prerequisite. There is no redundant phrasing or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple single-parameter, read-only status tool with an output schema and safety annotations, the description covers the key operational need: what is fetched and what token context is required. It could be slightly stronger by explicitly naming the expected usage flow relative to starting a release, but nothing critical is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There is only one parameter, workflowRunId, and the schema provides its type and UUID format but no semantic description. The tool description's phrase 'previously dispatched EAS Workflow run' gives some context that the ID refers to a prior workflow run, but it does not explicitly state that this ID is returned by start_mobile_release or how to obtain it.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Fetch') and a clear resource ('a previously dispatched EAS Workflow run and its build/submission jobs'), which makes the tool's purpose unambiguous. It also distinguishes this from sibling tools like start_mobile_release and check_mobile_release_readiness by focusing on fetching an existing run's status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'previously dispatched' implies this should be used after a release has been started, and the token requirement ties it to the dispatch action. However, there is no explicit guidance about when to prefer this over check_mobile_release_readiness or other related sibling tools, so the routing is only implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already establish read-only, idempotent, non-destructive behavior. The description adds useful context by showing the tool returns an orchestrated sequence (login → create org → connect .env → import menu → run) rather than performing those actions itself. This helps clarify the tool's informational nature, and it does not contradict the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that front-loads the goal and uses a compact arrow-separated list for the steps. There is no filler, and every part contributes to understanding what the tool provides.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With zero parameters, a rich set of safety annotations, and an output schema present, the description is complete for calling this tool. It tells the agent the tool returns an onboarding checklist, which is all that is needed to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so there are no parameter semantics for the description to clarify. The baseline of 4 applies; no additional parameter explanation is necessary.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the resource: a step-by-step onboarding flow from a restaurant repo to a live Crave-powered app, delivered as a checklist. It does not just restate the tool name and is distinguishable from related status tools, though it does not explicitly contrast with siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrasing 'How to take a restaurant repo from zero to a live Crave-powered app' implies the tool is for retrieving the onboarding sequence, but it does not explicitly say when to choose this over alternatives such as get_onboarding_status or start_crave_auth. Usage context is present, but no exclusions or alternative routing are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses deterministic generation, idempotence, and the refusal to operate on production hosts, production API processes, non-dev databases, or mismatched locations. Even though idempotentHint is already annotated, the production refusal and deterministic behavior add concrete runtime context. It does not explain return values or the dry-run/apply flow, but the output schema and mode parameter cover those.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two compact sentences place the purpose and scope first, and the guardrail behavior second. Every sentence earns its place with no filler or redundant enumeration of parameters.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is moderately complex, but the input schema covers 80% of parameters, an output schema exists, and annotations already declare idempotence and non-destructiveness. The description adds the critical dev-vs-production guardrail and data-domain overview. It is slightly incomplete only in not spelling out the dry-run-before-apply workflow on its own, though mode and planDigest schema descriptions effectively convey it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 80%, so the description can rely on the schema for parameter meaning. The prose only indirectly references location/confirmation via the dev organization, adding no syntax or format detail beyond what the schema already provides. This meets the high-coverage baseline but does not surpass it.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb and resource: 'Create deterministic customers, orders, ratings, and storefront funnel events' for a named dev organization. This clearly distinguishes the tool from sibling read/manage tools like list_customers or get_location_orders.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives a clear context clue by scoping to the Alvin's Test Hospitality Group dev organization and excludes production/non-dev environments. However, it never names alternative tools or states an explicit when-to-use condition such as 'use this when you need sandbox analytics seed data', leaving sibling comparison to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds useful behavior beyond the annotations: it preserves tax settings unless overridden and states the auth prerequisite. Annotations already cover read-only/destructive/idempotency, so the extra context is meaningful rather than redundant.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three tight sentences, each carrying distinct information: what the tool does, a side-effect safeguard, and a prerequisite. No repetition or padding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The dry-run/apply flow and confirmation token are covered by the rich schema, so the description does not need to repeat them. It provides the missing operational context (auth, tax preservation) and is complete enough for an agent to use the tool safely.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 57% schema coverage, the schema already documents mode, taxRate, planDigest, and confirmationToken. The description adds value by tying the tax-related parameters to preservation behavior, but enabled and locationId still get no semantic help beyond their names/types.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific action and resource: toggling order-ahead/scheduled orders when the restaurant is closed. It is clear, though it does not explicitly distinguish it from similar sibling tools such as set_takeout_enabled.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives a clear context for use ('when the restaurant is closed') and an important prerequisite (craveup login). It does not name alternative tools or state when not to use it, stopping short of explicit routing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate this is a write, idempotent, non-destructive operation. The description adds useful context beyond that: it explains why setting isActive matters, references the storefront fallback behavior, and notes the API key requirement. The dry-run/apply flow is left to the schema, but the description still contributes meaningful behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three short sentences, each earning its place: the purpose, the recommended workflow context, and the auth requirement. The description is front-loaded and contains no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with an output schema and strong annotations, the description covers the essential workflow, auth, and effect. It does not mention the dry-run/apply round-trip, but the input schema documents that. Overall the agent has enough context to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 50%, and the description does not compensate for the undocumented menuId, isActive, or locationId parameters. It clarifies the isActive concept indirectly, but it does not explain how menuId or locationId should be obtained or used, leaving a real gap for an agent.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb and resource: 'Set menu.isActive explicitly' and states the consequence for the storefront. It clearly distinguishes itself from related siblings by placing it in the import_menu/list_menus workflow.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives explicit guidance: 'Prefer after import_menu when list_menus shows isActive:false.' This identifies when the tool is appropriate in the workflow. It does not state exclusions or alternatives beyond that, but for this domain the guidance is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the description's 'read-only' statement is consistent. It adds useful behavioral context beyond the annotations: the specific checks performed and the EXPO_TOKEN prerequisite, though it does not disclose failure modes or what happens when prerequisites are missing.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two tight sentences: the first front-loads the read-only preflight purpose and target platforms, and the second lists the checks and the required prerequisite. No filler or redundant restatement of the tool name.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only readiness tool with a rich output schema and clear annotations, the description covers the essential context: what is checked, which platforms are supported, and what must be configured first. It could be slightly more complete by explicitly saying to run this before start_mobile_release and that success means the release can proceed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description carries some parameter burden. It indirectly explains target by naming 'internal TestFlight or Google Play internal testing,' which maps to the enum values, but it never mentions target or projectPath by name. projectPath is only covered by its schema default, leaving part of the parameter semantics implicit.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: a 'read-only Expo/EAS preflight' that 'checks app identity, production build profile, generated workflow, internal-only Android track, EAS project link, and EXPO_TOKEN.' It clearly distinguishes itself from siblings by emphasizing read-only readiness checks rather than starting or monitoring a release.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description makes the context clear: use as a preflight before internal TestFlight or Google Play internal testing, and it gives an explicit prerequisite: 'Run craveup apps configure first.' It does not explicitly contrast with siblings like start_mobile_release or get_mobile_release_status, but the intended placement is implied well.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Reveals important mutation behavior beyond the annotations: POST to /api/v1/locations, optional PATCH to /address, geocoding behavior when lat/lng are omitted, and the returned Crave location id. Annotations only indicate non-read-only and non-destructive, so these side-effect and auth details add real value. It doesn't mention the dry-run/apply mode, though that is covered in the schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The first three sentences are dense and front-load purpose, auth, behavior, and next steps. The final sentence about rebuilding @craveup/mcp and restarting the Cursor MCP server is a developer meta-note that doesn't materially help tool invocation, but the overall description still earns its length.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool with a rich schema and output schema, the description supplies the missing execution context: endpoint, required authentication, optional address behavior, return value, and suggested follow-up tools. No critical operational detail needed to invoke the tool correctly is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema already covers about 80% of parameters, so the baseline is 3, and the description adds some useful context such as 'pass lat/lng to skip geocoding.' However, the description says the request POSTs { restaurantDisplayName } while the actual required parameter is name, creating potential confusion for an agent mapping arguments to parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific action and scope: 'Create an additional location under the authenticated merchant (multi-location setup).' This clearly distinguishes it from siblings like list_locations, delete_location, and set_location_address. The verb, resource, and business context are all present.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives clear context: multi-location setup, requires craveup login and Clerk session, and lists follow-up tools such as update_store_hours and import_menu. It does not explicitly contrast with sibling tools or state when not to use it, so it stops short of full usage-exclusion guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds non-obvious behavioral context beyond the annotations: it creates both a merchant and default location, requires prior login, and will never return a plaintext API key. These complement annotations such as readOnlyHint=false and openWorldHint=true without contradicting them. Parameter-level behavior is left to the schema, which is reasonable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with no filler. The first sentence states the action and scope, and the second provides an essential credential caveat. Every clause earns its place, and it does not redundantly paraphrase schema properties.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is moderately complex with six parameters and a dry-run/apply flow, but the schema and output schema cover most parameter-level and return-value details. The description fills the important non-schema gaps: authentication requirement, default-location creation, and credential expectations. It does not narrate the dry-run/apply sequence, but that is already specified in the schema's mode and planDigest descriptions.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 83%, and the schema already documents mode, planDigest, confirmationToken, country, and mintApiKey. The description adds little parameter-specific meaning, except reinforcing that no API key is minted or returned, which overlaps with mintApiKey's const:false. The baseline of 3 is appropriate because the schema carries the parameter documentation burden.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: 'Create a new restaurant org (merchant + default location).' This is more specific than the title and distinguishes it from create_location by noting the tool also creates a default location. It is clear, non-tautological, and immediately tells an agent what the tool accomplishes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear preconditions: 'Requires craveup login' and directs users to create scoped credentials in Business Manager rather than expecting an API key from MCP. The purpose statement makes the primary use case obvious. It does not explicitly contrast with sibling tools like create_location, so it stops short of full alternative guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already establish readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds meaningful behavioral context beyond those annotations by mentioning 'fail-closed capability blockers' and 'safe runtime versions,' which indicates that the tool reports restrictions or blockers rather than merely providing general information. No contradiction with annotations exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description consists of two tight sentences. The first sentence front-loads the specific outputs, and the second sentence provides a clear usage directive. There is no padding or repetition of information already available in the schema or annotations.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no input parameters, rich annotations, an output schema, and a description that states both outputs and appropriate use context, the description is fully sufficient for an agent to select and call this tool correctly. There is no missing invocation-relevant detail.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so parameter-level explanation is unnecessary. With a 100% schema description coverage baseline and no parameters to document, the description does not need to compensate for missing parameter semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns three specific pieces of information: safe runtime versions, a tool-policy digest, and fail-closed capability blockers. It is clear about the tool's resource and purpose, though it does not explicitly distinguish itself from sibling tools such as get_integration_guide or the various readiness-check tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit guidance on when to use the tool: before project generation or long-running automation. It does not mention when not to use it or name alternative tools, but the stated context is clear and actionable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark it as non-read-only, non-destructive, and idempotent; the description adds useful behavioral detail by listing the three changes it applies and the login requirement. It does not mention the dry-run/apply flow, but that is carried by the input schema, so the description complements rather than contradicts the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no filler; the error symptom and required changes are front-loaded ahead of the login prerequisite. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutating tool with a rich input schema and output schema, the description covers the trigger, the actions, and the auth requirement. It could have added an explicit pointer to start_crave_auth or the dry-run-first sequence, but those are inferable from siblings and schema, leaving only a minor gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with all four parameters fully documented including enums, defaults, and the planDigest pattern. The description adds no parameter-level detail, so the schema-coverage baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('fixes') plus a concrete error message and the exact configuration changes (24/7 hours, scheduled orders, takeout). This distinguishes it from single-purpose siblings like update_store_hours or set_takeout_enabled without needing to name them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly ties the tool to a specific error condition, telling an agent when to invoke it, and notes the prerequisite login. It does not explicitly contrast with individual sibling tools or state when not to use it, but the error-message trigger provides clear context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds meaningful behavioral context beyond annotations: it consumes paid EAS build minutes, requires a scoped robot user token, and cannot publish publicly. It could mention side effects or rollback, but the cost and authorization disclosure is strong.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Four sentences, each carrying real content: pipeline, cost, prerequisites, and platform/store scope. The main action is front-loaded and there is no filler or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the 8-parameter, paid, release-oriented operation, the description adequately covers action, prerequisites, and exclusions while the schema covers the dry-run/apply flow and output schema covers return values. It would be stronger if it explicitly referenced the readiness/status siblings or the two-phase flow, but nothing critical is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Description adds EXPO_TOKEN context and reinforces confirmation gating, but it does not explain gitRef or changelog semantics, nor does it disambiguate confirmationToken from confirmation. The schema already covers most parameter formats, so this is adequate but not exceptional.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description names a specific action ('dispatch'), a specific resource ('committed Crave Up EAS Workflow'), and a specific target ('internal TestFlight'), while explicitly ruling out public store publication. This clearly differentiates start_mobile_release from the readiness/status siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit context and exclusions: Android stays CLI-only, public store publishing is not possible, and EXPO_TOKEN plus an exact confirmation phrase are required. It does not name an alternative sibling tool, but the when-not guidance is concrete and actionable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is fully covered. The description adds that this is informational documentation, but does not reveal additional behavioral nuance, so it lands at the baseline for annotation-covered tools.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, both purposeful. The first sentence front-loads the scope and contents; the second gives clear action guidance. No filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-enum-parameter tool with a full output schema and strong annotations, the description covers what the tool is, what it contains, and when to use it. Nothing an agent needs to call it correctly is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the enum values are described. The description adds value by mapping each enum to a concrete guide topic ('SDK setup', 'menu display', 'checkout flow', 'bulk menu import format'), helping the agent pick the right topic without additional research.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description names the specific resource ('Crave storefront implementation guidance') and lists the exact guide topics: SDK setup, menu display, checkout flow, and bulk menu import format. This clearly distinguishes it from sibling tools like get_onboarding_flow or check_storefront_readiness.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit usage context: 'Read the relevant guide before writing storefront code.' It does not name alternatives or exclusions, but the timing and purpose are clear enough for an agent to know when to invoke it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover readOnly, idempotent, openWorld, and non-destructive behavior. The description adds the login requirement ('Requires craveup login') and the data-source equivalence with the Orders Manager, which are useful behavioral details beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences with no wasted words. The main operation and scope are front-loaded, and the auth prerequisite earns its place as essential usage information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only list tool with an output schema, safety annotations, and fully described parameters, the description covers the operation, scope, data source, and auth requirement. Nothing essential is missing for an agent to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The single parameter locationId is fully described in the schema, including the default behavior when omitted ('Omit to use CRAVEUP_LOCATION_ID'). With 100% schema coverage, the baseline of 3 applies; the description adds no additional parameter-level detail.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: 'Fetch active (new) orders for a location,' reinforced by the title 'List active orders at a location.' The phrase 'same data as the Orders Manager' adds clarity and helps distinguish it from the many setup/management sibling tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear context for when to use the tool: retrieving active orders for a location, and notes the login prerequisite. It does not name explicit alternatives or exclusions, but no sibling tool serves the same order-fetching purpose, so the guidance is sufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context by specifying the authentication requirement and exactly which settings are fetched. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, tightly packed sentence that front-loads the action and the data being fetched, followed by the auth requirement. There is no filler, redundancy, or restating of the tool name.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only tool with one optional parameter, the description is complete: it states what is returned, the authentication needed, and the scope. The output schema handles return-value documentation, and annotations handle the safety profile. No critical information is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, and the single optional parameter locationId is fully documented in the schema, including the fallback to CRAVEUP_LOCATION_ID. The description adds no additional parameter-level semantics, so it meets the baseline 3 for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Fetch') and names the exact resource: store hours, scheduled-order flag, tax settings, and takeout config for a location. This clearly distinguishes it from sibling mutation tools like update_store_hours, set_scheduled_orders_enabled, and set_takeout_enabled, as well as from list_locations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The context is clear: use this tool to retrieve read-only settings for a location. The description also states the authentication prerequisite (CraveUp login), which is important operational guidance. However, it does not explicitly name alternative tools for mutating those settings, so the when-not-to-use guidance is only implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, so the safety profile is well covered. The description adds meaningful context beyond those annotations by disclosing the API key requirement and that the API verifies key access to the requested location, which is directly useful for invocation planning.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no filler: the core behavior is front-loaded, and the authentication requirement follows immediately. Every word contributes to helping the agent understand what the tool does and what is needed to call it.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-optional-parameter read-only tool with a rich annotation set and an output schema, the description is complete. It covers the essential invocation context (API key requirement, authorization check, location scoping) without needing to explain return values because the output schema exists.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% and the locationId parameter already includes a clear 'Omit to use CRAVEUP_LOCATION_ID' explanation. The description reinforces that the operation targets 'one authorized location' but adds no new parameter-level semantics beyond what the schema provides, so the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('List') and resource ('every discount configured for one authorized location'), making the tool's purpose immediately clear. It also distinguishes itself from write-sibling create_order_discount by focusing on enumeration, and from list_locations by targeting discounts rather than locations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context: this tool lists discounts for a single authorized location and requires a Crave merchant API key. It does not explicitly name alternatives or when-not-to-use conditions, so it falls short of a 5, but the purpose is specific enough for an agent to route correctly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already establish that the tool is read-only, idempotent, and non-destructive. The description adds useful context beyond those hints by specifying that the operation is scoped to the authenticated merchant and that it requires a craveup login, which addresses authentication requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three short sentences, each adding distinct value: what the tool does, when to use it, and what prerequisite is needed. There is no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a simple read-only list operation with one optional parameter, an output schema, and strong annotations. The description covers the tool's purpose, use case, scope, and authentication requirement, so nothing essential is missing for an agent to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the single optional limit parameter is fully documented in the schema with min, max, and default. The description does not need to repeat parameter information, and the baseline of 3 applies given the high coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific verb and resource: 'List locations for the authenticated merchant.' It also adds the dashboard context ('dashboard locations-stats') and a concrete use case, which distinguishes it from related location tools like create_location, get_location_settings, and delete_location.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides a clear use case: 'Use to verify multi-location setup without opening the browser.' It does not explicitly name alternative tools or exclusion conditions, but the intended purpose is clear enough for an agent to decide when to call it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds value by revealing the exact hierarchy returned and the relationship to the storefront API, which is useful behavioral context beyond the annotations. No contradiction exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no filler. The core behavior is front-loaded, and the usage intent is stated in the second sentence. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only list operation with rich annotations and an output schema present, the description covers the task, scope, and intended use cases. Nothing essential is missing for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% and the sole parameter, locationId, is adequately documented in the schema with the default behavior explained. The tool description adds no parameter-specific detail beyond that, so the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('read back') and resource ('menus') and explicitly defines the scope as menus → categories → products exactly as the storefront API serves them. It differentiates from siblings like import_menu, set_menu_active, and get_product by emphasizing read-only inspection of the hierarchical menu structure.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description states clear use cases: 'verify an import or inspect current state.' It does not explicitly enumerate exclusions or alternatives, but the purpose is unambiguous and the intended context is well conveyed. Missing an explicit 'when not to use' keeps it from a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds meaningful context by specifying the credential sources queried (CLI keychain or CRAVEUP_ACCESS_TOKEN), which is useful auth-related behavior beyond what the annotations provide. It does not cover failure behavior, but this is a minor gap given the output schema exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, focused sentence that front-loads the action, names the resource, and includes the key credential context. Every part contributes meaning and there is no redundant wording.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter, read-only verification tool with robust annotations and a declared output schema, the description is complete. It tells the agent exactly what is verified and where credentials come from, and the output schema covers the return shape, so nothing essential is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters and the schema description coverage is 100%, so there is nothing for the description to add about parameters. Per the baseline for zero-parameter tools, this is adequate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb, 'Verify', and names the exact resource: the MCP server's ability to read a craveup login session. It also identifies the credential sources (CLI keychain or CRAVEUP_ACCESS_TOKEN), making the tool's purpose unmistakable and clearly distinct from auth-flow siblings like start_crave_auth and complete_crave_auth.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description states what the tool does but does not explicitly say when to use it versus alternatives, and it does not mention that this should be used to check an existing session before starting a new auth flow. The usage context is implied by the action 'Verify' and the sibling tool names, but no explicit when/when-not guidance is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already convey idempotency, non-destructiveness, and the mutation nature. The description adds useful behavioral detail by specifying that the cancellation also closes the local callback, which goes beyond the structured metadata. There is no contradiction with the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler. Every phrase earns its place: the action, the target resource, and the local side effect are all stated efficiently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With zero parameters, an output schema, and annotations covering idempotency and destructiveness, the description is sufficient for an agent to invoke the tool correctly. It could mention the relationship to start_crave_auth or complete_crave_auth more explicitly, but the sibling names and the term 'pending' supply enough context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
This tool has zero parameters, so the description bears no burden for parameter documentation. The schema fully covers the parameter surface, and the description accurately focuses on the tool's action instead.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Cancel') and names the resource ('pending browser authentication flow') and the side effect ('close its local callback'). This clearly distinguishes it from siblings like start_crave_auth and complete_crave_auth, which handle initiation and completion rather than cancellation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'pending browser authentication flow' gives clear context for when this tool should be used. It does not explicitly list excluded cases or name siblings as alternatives, but the pending-flow framing is enough to guide an agent toward the correct lifecycle stage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate idempotent behavior and a non-read-only operation. The description adds useful behavioral context: it returns a URL, the agent must open it for the user, and the user can authenticate without leaving the flow. No contradiction with the annotations is present.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two short sentences with no filler. It leads with the core purpose, then immediately gives the actionable next step for the agent, making the most important information easy to scan.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter start-flow tool, the description covers what the agent needs to do: invoke it, take the returned URL, and open it for the user. A small gap is that it does not explicitly mention the continuation step (complete_crave_auth), but the flow context and sibling naming make this reasonably inferable.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so there is no parameter detail for the description to provide. The baseline for parameter-free tools is 4, and the description appropriately focuses on the action and returned URL rather than inventing parameter guidance.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a clear verb ('Start secure browser authentication') and an explicit resource ('for CLI and MCP access'), plus what the user will do (sign in or create an account). It is easily distinguished from the sibling tools complete_crave_auth and cancel_crave_auth by the 'start' framing.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly positions this as the initial step in a browser-based auth flow and explains that the agent should open the returned URL. It does not explicitly name complete_crave_auth or cancel_crave_auth as follow-up/alternative tools, but the start-versus-complete/cancel distinction is strongly implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations only provide coarse flags, so the description carries most of the behavioral burden. It adds valuable context: the human must open the URL, webhook latency exists, checkout is production-only, and login is required. It does not, however, surface the paid-operation confirmation-token requirement or the dry-run/apply sequencing, which are important behavioral traits beyond the raw schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Five short sentences, each earning its place: the core action, the user step, the post-payment polling behavior, the environment restriction, and the auth requirement. The most important information is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Paired with the complete schema and output schema, the description gives the agent enough to act. However, the two-phase dry-run/apply flow and the confirmation-token requirement for paid operations are only present in the schema, not in the operational narrative, leaving a real gap for a non-trivial paid checkout flow.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, and the schema already explains mode, priceId, returnUrl, planDigest, and confirmationToken. The description only indirectly references the plan via 'chosen plan' and adds no real parameter-level meaning, so it stays at the baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action and resource: 'Create a Stripe Checkout URL for the chosen plan.' This clearly separates it from sibling tools like list_subscription_plans, get_onboarding_status, and auth tools, and it even identifies the follow-up polling step.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives explicit when-to-use context: give the URL to the user because card entry cannot be automated, poll get_onboarding_status after payment, and avoid this tool in sandbox because a subscription is not required there. It also names the auth prerequisite.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the read-only and idempotent annotations, the description explicitly guarantees no cart creation, no PaymentIntent, no Square payment, and no reliance on dashboard isOnboardingCompleted. It also clarifies the authoritative payment provider logic and CRAVEUP_API_KEY requirement, providing rich behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is dense but efficient, leading with the core purpose and then adding only essential constraints: what is verified, side-effect guarantees, payment provider logic, and auth requirements. Every sentence adds value and there is no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With one optional parameter and an output schema present, the description covers everything needed for correct invocation: object, checks, fallback behavior, side-effect absence, auth requirements, and intentionally avoided data sources. Nothing material is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already documents locationId at 100% coverage, including the 'omit to use CRAVEUP_LOCATION_ID' behavior. The description mentions CRAVEUP_API_KEY in an auth context but does not add new parameter-level semantics beyond the schema, so the baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool as a readiness probe and enumerates exactly what it checks: menu has products, takeout availability via a read-only GET, and payment configuration readiness. This makes both the verb and resource unambiguous and distinguishes it from onboarding or order-management siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides concrete context for when the result is meaningful, including the Square-authoritative-versus-Stripe fallback logic and the public/private API key distinction. However, it does not explicitly name alternative tools or state when not to use this tool, so some sibling-routing is left to the agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds useful behavioral context beyond annotations by noting that the shared CLI/MCP session is saved securely and that this step completes an existing browser login. It does not contradict the idempotentHint or readOnlyHint annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, compact sentence conveys the action, prerequisite, and outcome with no redundancy or filler. Every word contributes to understanding when and why to call the tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter, idempotent tool with an output schema, the description sufficiently covers the prerequisite start_crave_auth step, the action of completing login, and the result of saving the session. No additional invocation-relevant details are missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the input schema fully describes the parameter surface. The description appropriately avoids inventing parameter details, and a no-parameter tool warrants the baseline score of 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action: completing a browser login initiated by start_crave_auth and saving the shared session. It differentiates itself from the sibling start_crave_auth and cancel_crave_auth by describing the completion step of the auth flow.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description establishes the correct context by referencing a login 'started by start_crave_auth', making it clear this tool is the follow-up step. It does not explicitly discuss when not to use it or compare with cancel_crave_auth, so it stops short of full exclusion guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already include destructiveHint=true and readOnlyHint=false, and the description meaningfully elaborates beyond these: it specifies what is modified (archivedAt, slug, location list, Clerk org metadata) and what is preserved (order/menu rows for audit). It also discloses an authentication requirement. No contradiction with annotations exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences with no filler. Each sentence earns its place: first states the operation and effects, second clarifies retention/audit behavior and use case, third gives an auth prerequisite. Information is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is complete for this tool's complexity: it covers what the operation does, what remains intact, when to use it, and the login requirement. The input schema fully documents parameters, and an output schema exists, so return-value details are not required here.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, and every parameter already has a meaningful description, including dry-run/default behavior and the planDigest requirement. The tool description adds no extra parameter-level guidance, so the baseline score of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific verb ('Soft-deletes') and resource ('a location'), then enumerates concrete effects (sets archivedAt, frees the slug, removes from merchant location list and Clerk org metadata). It also differentiates this from a hard delete by noting order/menu rows remain for audit, distinguishing it from a sibling like delete_product.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
'Use to remove unused duplicates' gives an explicit intended use case, and 'Requires craveup login' adds an operational prerequisite. It does not explicitly name alternative tools or state when not to use it, but the purpose and context are clear enough for an agent to select it appropriately.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the idempotentHint annotation, the description discloses the mechanism: 're-importing updates existing items by name instead of duplicating.' It also surfaces a non-obvious side effect: 'Forces menu.isActive=true unless explicitly set false.' These are actionable behavioral details not present in the annotations, and there is no contradiction with them.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is four sentences, each earning its place: scope of import, source use-case, idempotency behavior, activation default and follow-up. It is front-loaded with the core action and contains no filler or restatements of schema fields.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with nested objects and a two-phase dry-run/apply flow, the description orients the agent well on the bulk import scenario, idempotency, and post-import activation. It does not mention the required dry-run-then-apply workflow or confirmationToken, but the schema's mode and planDigest descriptions fully cover those, so the gap is minor.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3 even without parameter details in the description. The description adds meaningful semantics by explaining that re-import matches items by name and that isActive defaults to true unless set otherwise, which reinforces and extends the schema's weightier parameters. It does not duplicate enum or format details.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action ('Store a complete menu ... at a Crave location in one call') and enumerates exactly what is included: categories, products, prices, image URLs, modifiers. This clearly distinguishes it from sibling tools like update_product, delete_product, and set_menu_active, which operate on a single item or activation state.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit context: 'Use this after extracting a menu from a website, PDF, or photos,' and provides a follow-up action ('Follow with set_menu_active if needed'). However, it does not explicitly state when not to use the tool or name alternatives for partial updates, so it stops short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds substantial behavioral context beyond the readOnly/idempotent annotations: sandbox vs. production differences, Stripe KYC handling, the meaning of completing all six steps, and the login prerequisite. It provides actionable guidance about what the agent should do with the results.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is four focused sentences, front-loaded with the core function, then adding only necessary environment and action details. Every sentence earns its place, and there is no redundant restating of the tool name or title.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no parameters and an output schema that handles return values, the description covers all remaining context: the steps involved, sandbox/prod nuance, the Stripe KYC action, completion semantics, and authentication. The agent can correctly decide when to call it and how to act on the result.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are zero parameters, so the schema provides no opportunities for ambiguity. The description appropriately focuses on behavior and output rather than parameter details, which is enough for a parameterless tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific verb ('Fetch'), a concrete resource ('the 6 dashboard go-live steps'), and the data returned (completion state, suggested next action). It clearly differentiates itself from siblings like get_onboarding_flow by focusing on status and next actions rather than the flow definition.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description makes the primary use case obvious: retrieve go-live onboarding status and drive the user through required next steps. It doesn't explicitly name alternatives or exclusion conditions, but the context is clear enough that an agent would know when to invoke it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover read-only, idempotent, non-destructive behavior. The description adds meaningful context beyond those annotations by specifying the production-only constraint and the requirement for a craveup login, which are not captured in the structured annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three short sentences with no filler. The action and key fields come first, followed by downstream routing and environment requirements, so the most decision-relevant information is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With zero parameters, an output schema present, and annotations covering the safety profile, the description provides everything needed to call and use the tool correctly: login requirement, environment constraint, returned fields, and downstream integration.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the baseline is 4. The description adds value by listing the output fields (name, price, billing interval, trial) and explaining how the resulting priceId is used, which helps an agent interpret the tool's response without any input schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb and resource ('List available subscription plans') and names the key fields (name, price, billing interval, trial), making the tool's purpose unmistakable. It also differentiates itself from start_subscription_checkout by explicitly pointing to the priceId relationship.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It clearly states when the tool is needed: production use, while sandbox development does not require a subscription. It also names the downstream tool to use with the returned priceId, giving an agent concrete routing guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

CraveUp MCP Server MCP server — quality and maintenance score on Glama

Copy to your README.md:

[![CraveUp MCP Server MCP server — quality and maintenance score on Glama](https://glama.ai/mcp/servers/craveup-oss/craveup-mcp/badges/card.svg)](https://glama.ai/mcp/servers/craveup-oss/craveup-mcp)

Score Badge

Copy to your README.md:

[![CraveUp MCP Server MCP server — quality and maintenance score on Glama](https://glama.ai/mcp/servers/craveup-oss/craveup-mcp/badges/score.svg)](https://glama.ai/mcp/servers/craveup-oss/craveup-mcp)

shields.io Endpoint

For READMEs with an existing badge row. Append &style=flat-square (or any other shields.io style) to match the rest, and &metric=tools, &metric=maintenance or &metric=claim to badge a different dimension.

[![CraveUp MCP Server MCP server — quality and maintenance score on Glama](https://img.shields.io/endpoint?url=https%3A%2F%2Fglama.ai%2Fmcp%2Fservers%2Fcraveup-oss%2Fcraveup-mcp%2Fbadges%2Fshields.json)](https://glama.ai/mcp/servers/craveup-oss/craveup-mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/craveup-oss/craveup-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server