Free directory of youth programs and licensed daycares in Lodi, CA. 72 tools.
Glama MCP Gateway
Connect through Glama MCP Gateway for full control over tool access and complete visibility into every call.
Full call logging
Every tool call is logged with complete inputs and outputs, so you can debug issues and audit what your agents are doing.
Tool access control
Enable or disable individual tools per connector, so you decide what your agents can and cannot do.
Managed credentials
Glama handles OAuth flows, token storage, and automatic rotation, so credentials never expire on your clients.
Usage analytics
See which tools your agents call, how often, and when, so you can understand usage patterns and catch anomalies.
Average 3.5/5 across 72 of 72 tools scored. Lowest: 2.2/5.
Tools are clearly grouped by prefix (admin_, daycare_, org_, parent_) and within each group have distinct, non-overlapping purposes. For example, parent_add_kid vs parent_remove_kid are unambiguous.
All tools follow a consistent snake_case pattern with role prefix and action_noun structure. Minor exceptions like 'nearby_programs' are standalone and do not disrupt the overall consistency.
With 72 tools, this is far beyond the typical well-scoped range of 3-15. While the tools cover multiple user roles, the count is excessive and likely overwhelming for an agent, falling into the 'too many' category.
The tool set covers most core workflows for parents, orgs, and admins, but notable gaps exist: there is no tool to create a program or daycare, and admin tools for approving pending claims or discoveries are missing, leaving dead ends.
admin_cost_summaryAInspectMonth-to-date spend across Anthropic / Firecrawl / Serper / Apify / Resend / Twilio (when each logger is in place).
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states it shows month-to-date spend but lacks details on error behavior (e.g., missing loggers) or data freshness.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, no redundancies, effectively front-loaded with the key purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema or annotations, the description is fairly complete, but could clarify whether spend is per-service or aggregated, and behavior when loggers are absent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0 parameters, the baseline is 4. The description adds meaning by listing specific service names, which enriches the understanding of the tool's scope.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description specifies a verb (spend) and resource (cost for listed services) and distinguishes it from sibling admin tools like admin_live_activity or admin_mcp_stats.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when loggers are in place, but does not provide explicit when-not-to-use or alternative tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
admin_live_activityAInspectLast 24h of activity across the platform — signups, saves, contacts, claims, discoveries.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses the time window (last 24h) and the types of activities covered, indicating a read-only operation. However, it does not mention data freshness, rate limits, or whether the tool is safe to call repeatedly. The disclosure is adequate but minimal.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that covers the essential information: time period and types of activity. Every word serves a purpose, and there is no redundancy or extraneous text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no parameters and no output schema, and the description is minimal. It provides enough information to understand the tool's purpose but lacks behavioral details like read-only confirmation, response format, or error scenarios. For a simple read tool, this is adequate but leaves gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and the input schema is empty with 100% coverage. Since there are no parameters, the description naturally does not add parameter semantics. Per guidelines, a zero-parameter tool gets a baseline score of 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly conveys that the tool retrieves the last 24 hours of activity across the platform, listing specific activity types. While it does not use an explicit verb like 'list' or 'get', the meaning is clear and distinguishes it from sibling admin tools like admin_pending_claims or admin_cost_summary.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when a broad overview of recent platform activity is needed, but it offers no explicit guidance on when to use this tool over alternatives, nor any exclusion criteria. Sibling tools like admin_pending_claims are implicitly differentiated by content, but this is not stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
admin_mcp_statsAInspectMCP call volume + top tools + top agents in the last 7 days.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries full burden. It does not disclose behavioral traits such as authentication requirements, rate limits, performance implications, or whether data is live or cached. Only the output content is hinted.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that conveys all necessary information with no wasted words. It is appropriately front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given zero parameters and no output schema, the description is fairly complete about the data returned. However, it could include output format details or a usage example to be fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are zero parameters, so baseline is 4. The description adds meaning by specifying what the output will contain (call volume, top tools, top agents), which is beyond the empty schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb (provides) and the resources (MCP call volume, top tools, top agents) within a specific time frame (last 7 days). It distinguishes from sibling tools like admin_cost_summary which focus on cost rather than usage stats.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is for retrieving MCP stats, but does not explicitly state when to use it versus alternatives like admin_live_activity or admin_search_trends. No when-not-to-use guidance is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
admin_pending_claimsAInspectPending org + daycare claim REQUESTS (someone applied to claim but admin hasn't approved). Excludes the long tail of seed orgs that have no contact info yet.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of behavioral disclosure. It accurately describes the tool as listing pending requests, implying a read-only operation. It explicitly mentions exclusions, which adds transparency. However, it doesn't explicitly state that the tool has no side effects or that it is safe to call, which would be helpful.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence followed by a clarifying parenthetical. Every word contributes meaning, and the core purpose is front-loaded. There is no redundancy or unnecessary detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no parameters, no output schema, and a clear description, it is mostly complete. It explains exactly what data is returned and what is excluded. However, it does not mention ordering, pagination, or how results are sorted, which could be useful for an admin tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the schema requires no additional explanation. The baseline for no parameters is 4. The description does not need to elaborate on parameters as none exist.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists pending org and daycare claim requests. It specifies the resource type ('claim REQUESTS') and the status ('someone applied but admin hasn't approved'), distinguishing it from other admin tools like admin_pending_discoveries.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context on what is included (pending claim requests) and excluded (seed orgs without contact info). While it doesn't explicitly state alternatives or when-not to use, the exclusion criterion offers implicit guidance. With sibling tools like 'admin_pending_discoveries', the distinction is reasonably clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
admin_pending_discoveriesCInspectPending discoveries in admin queue.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits, but it only states what the tool returns (pending discoveries) without mentioning safety, permissions, or side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise, but it sacrifices necessary detail—it is under-specified rather than efficiently informative.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the single parameter and lack of output schema, the description should clarify the tool's purpose and behavior, but it remains incomplete for effective agent use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%; the optional 'limit' parameter is not explained in the description, leaving the agent to infer its purpose from the schema alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Pending discoveries in admin queue' is vague; it does not specify the action (e.g., list, view) and fails to differentiate from sibling tools like admin_pending_claims or admin_pending_guides.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives; no context about prerequisites or use cases is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
admin_pending_guidesDInspectPending editorial guide drafts.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, and the description offers no behavioral information (e.g., read-only, authorization, pagination). The tool could be a mutation or a read; nothing is disclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Extremely short (5 words), but it is more of a title than a description. It lacks front-loading of key information and feels incomplete rather than concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no schema, no annotations, and no output schema, the description must compensate. It fails to describe return values, purpose, or usage context, making it completely inadequate for an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are no parameters, and schema coverage is 100%. Baseline is 3. The description adds no parameter meaning, but none is needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Pending editorial guide drafts' is a noun phrase, not a verb+resource. It does not explicitly state what the tool does (e.g., list, view, count). The name suggests listing, but the description is vague.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus siblings like admin_cost_summary or admin_pending_claims. The description provides no context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
admin_search_trendsCInspectTop parent search queries in the last 30d. Reads parent_search_queries.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries the full burden. It states 'Reads parent_search_queries', implying read-only behavior, but does not disclose authentication requirements, permission levels, rate limits, or whether the data is cached. The behavioral disclosure is minimal.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, efficient and to the point. It front-loads the key information. However, it could be slightly more structured (e.g., separate param info) without losing conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and only one parameter, the description should provide more context about return values, sorting, whether 'top' means most frequent, and data freshness. It mentions 'last 30d' but omits important contextual details like if admin privileges are required.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, meaning the description should explain the 'limit' parameter, but it does not mention it at all. The description only says 'top parent search queries' without noting that results can be limited via the optional parameter. The schema provides min/max but no purpose.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool retrieves 'top parent search queries in the last 30d' and 'reads parent_search_queries'. The verb 'reads' and resource 'top parent search queries' are specific. Among siblings, this is the only tool with 'trends' in the name, so it distinguishes well, though it could be more explicit about its admin-only nature.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives. The description does not mention when it is appropriate or inappropriate to use, nor does it provide context about prerequisites or comparison with sibling tools like admin_cost_summary or admin_live_activity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
city_statsAInspectAggregate stats for a city: # programs, # daycares, % claimed by owners, % with Spanish description, % free, category breakdown. Useful for AIs answering 'how many youth programs are there in Lodi' or comparing Lodi to other cities.
| Name | Required | Description | Default |
|---|---|---|---|
| city_slug | No | City slug (e.g. 'lodi'). Defaults to 'lodi' if omitted. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries full burden. It describes the output (stats) but does not explicitly state read-only behavior, auth requirements, or any side effects. The information is adequate for a non-destructive aggregation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences with no redundancy. The first sentence lists key outputs, the second provides typical use cases. Front-loaded and efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with one optional parameter and no output schema, the description covers the necessary scope. It could mention data freshness or interpretation of percentages, but the core information is sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with one optional parameter. The description adds that city_slug defaults to 'lodi', which goes beyond the schema description and clarifies behavior.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description lists specific aggregated statistics (programs, daycares, percentages) and provides example queries, making the tool's purpose clear and distinct from sibling tools like get_program or search_programs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly suggests use cases (answering counts or comparisons), which guides when to use it. While it doesn't mention alternatives, the sibling list implies no other tool provides city-level aggregation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
daycare_capacityBInspectGet current capacity by age band for the daycare(s) this org owns.
| Name | Required | Description | Default |
|---|---|---|---|
| daycare_id | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. It states the operation is a read of current capacity, but does not mention authentication requirements, rate limits, or behavior when the optional parameter is omitted. The return format is not described, leaving gaps for an AI agent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, 12-word sentence that is efficient and front-loaded. However, it may be overly terse, missing details that could enhance clarity without significant bloat.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one optional param, no output schema), the description is incomplete. It fails to clarify the behavior when 'daycare_id' is omitted, the structure of the response (e.g., array of age bands), or any limitations. An agent may require additional assumptions.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has one optional parameter 'daycare_id' with no description (0% coverage). The tool description adds 'by age band' context but does not explain the parameter's semantics, such as whether omitting it returns all daycares or the expected format. The added value is minimal.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get', the resource 'current capacity', and the scope 'by age band for the daycare(s) this org owns'. It effectively distinguishes from sibling tools like 'daycare_set_capacity' and other admin queries.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for querying capacity of owned daycares but provides no explicit guidance on when to use this tool versus alternatives like 'daycare_set_capacity' or other admin tools. No exclusions or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
daycare_list_applicationsCInspectSubmitted applications for the org's daycare.
| Name | Required | Description | Default |
|---|---|---|---|
| status | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description should explicitly state that the tool is read-only and non-destructive. 'Submitted applications' implies a read operation, but it is not stated, and no other behavioral traits are mentioned.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence with no unnecessary words, but it lacks any details that would improve its utility.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one optional parameter, the description does not explain what constitutes 'applications', the return format, or pagination, leaving incomplete context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has one parameter 'status' with 0% description coverage, and the tool description provides no explanation of valid values or how the parameter affects results.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool as listing submitted applications for the org's daycare, distinguishing it from sibling tools like daycare_list_tours or daycare_list_waitlist.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives, such as filtering by status or comparing to other listing tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
daycare_list_toursCInspectTour requests for the org's daycare(s).
| Name | Required | Description | Default |
|---|---|---|---|
| status | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description bears full responsibility. It does not disclose read-only nature, authentication requirements, or any side effects. Simply stating 'Tour requests' is insufficient for an agent to understand behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence, which is concise but lacks necessary detail. It is not verbose, but it sacrifices completeness for brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has one optional parameter and no output schema or annotations, the description is too brief. It fails to explain what the response contains, who the intended user is, or how results are organized. This is inadequate for reliable agent invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The only parameter (status) is not mentioned in the description. With schema coverage at 0%, the description must explain the parameter, but it does not. The agent cannot infer filtering capability from the description alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool lists tour requests for the org's daycares, which is clear enough and distinguishes from sibling tools like parent_list_tours or daycare_respond_to_tour. However, it could be more explicit about the perspective (org admin) and the context.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. Sibling tools like parent_list_tours and daycare_respond_to_tour serve different roles, but the description offers no hints about when to choose this one.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
daycare_list_waitlistDInspectCurrent waitlist queue for the org's daycare.
| Name | Required | Description | Default |
|---|---|---|---|
| daycare_id | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It does not disclose any behavioral traits such as read-only nature, authentication requirements, rate limits, or what the response contains. It only states 'Current waitlist queue', which is insufficient for an AI agent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely short (five words), but it is a noun phrase without a verb, making it less clear. While concise, it sacrifices necessary detail and is not front-loaded with an action verb.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has one parameter, no output schema, and no annotations, the description is severely lacking. It does not explain what the tool returns, how to use the parameter, or any context about the waitlist (e.g., whether it's a list of names or IDs).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must explain the 'daycare_id' parameter. It does not mention the parameter at all, leaving its meaning and behavior (e.g., optionality, effect of omission) completely unspecified.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Current waitlist queue for the org's daycare' indicates the resource is the waitlist, but uses a noun phrase rather than a verb. It implies listing, but does not explicitly state the action. It distinguishes from sibling tools like 'daycare_capacity' and 'daycare_list_applications', but the purpose is somewhat vague.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. For example, it does not clarify whether to use 'daycare_list_applications' for applications vs 'daycare_list_waitlist' for waitlist. No when-not-to-use or alternative references.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
daycare_respond_to_tourAInspectRespond to a tour request — confirm with a date/time, propose alternates via notes, or decline.
| Name | Required | Description | Default |
|---|---|---|---|
| note | No | ||
| tour_id | Yes | ||
| response | Yes | ||
| confirmed_date | No | YYYY-MM-DD; required if response='confirm' | |
| confirmed_time | No | e.g. '10:30am' |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must carry the burden. It mentions that notes can propose alternates, but does not disclose side effects (e.g., notifications, state changes), permissions needed, or what happens after confirmation/decline.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence (17 words) is extremely concise, front-loaded with the verb 'Respond', and every word adds value with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Description covers essential behaviors but lacks details on return values, success/failure indicators, and conditional requirements (e.g., confirmed_date required for confirm). For a tool with 5 params and no output schema, more completeness is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 5 parameters with only 40% description coverage. Description adds meaning by linking confirmed_date/time to confirm and note to proposing alternates, clarifying parameter usage beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description uses specific verb 'respond' and resource 'tour request' and distinguishes actions (confirm, decline, propose alternates). Clearly different from sibling tools like parent_request_tour and parent_cancel_tour.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Description implies usage context (responding to a tour request) but does not explicitly state when to use this vs. alternatives, nor does it mention prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
daycare_set_capacityCInspectUpsert capacity for one age band on a daycare. Age bands: infant, toddler, twos, threes, fours, prek, kindergarten.
| Name | Required | Description | Default |
|---|---|---|---|
| notes | No | ||
| age_band | Yes | ||
| daycare_id | Yes | ||
| total_slots | Yes | ||
| waitlist_count | No | ||
| current_enrollment | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It only says 'upsert' but doesn't disclose whether it overwrites existing capacity, requires specific permissions, or affects waitlist/enrollment. This is insufficient for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise (two sentences) but under-specified. It front-loads the action but omits necessary detail about parameters and behavior. It is not wasteful but is too brief for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 6 parameters, no output schema, and no annotations, the description leaves significant gaps. It does not explain return values, error handling, or partial update behavior, making it incomplete for reliable use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must explain parameters. It only lists age bands but does not clarify the meaning or usage of notes, total_slots, waitlist_count, or current_enrollment. The schema constraints are present but their purpose is undocmented.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Upsert capacity for one age band') and the resource ('on a daycare'), listing all valid age bands. This distinguishes it from sibling tools like daycare_capacity (likely read-only) and org_update_program_capacity (different context).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool vs alternatives, such as daycare_capacity for reading capacity or org_update_program_capacity for program capacity. No prerequisites or exclusions are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
featured_listingsAInspectReturns the currently-promoted programs on the LKA homepage. Reads from featured_listings table within the active date window.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Given no annotations, the description provides good transparency by stating the read operation from a specific table with an active date window. No side effects or destructive behavior implied.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences front-load the core purpose and source. No unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Description lacks return format details (e.g., list of program objects, fields). With no output schema, mentioning the structure would improve completeness. Otherwise adequate for a simple listing tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist, and schema coverage is 100%. The description adds no param info, which is acceptable since there are none. Baseline of 4 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool returns 'currently-promoted programs on the LKA homepage', specifying the source table and date window. This is specific and distinguishes it from siblings like 'search_programs' or 'list_categories'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Description makes the use case obvious (to get featured listings). However, it does not explicitly state when not to use it or provide alternatives, though the context of sibling tools makes the purpose clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_daycareAInspectGet full details for a single daycare by slug, including capacity by age band (infant / toddler / 2s / 3s / 4s / pre-K / kindergarten) when the daycare has filled it in. Use after search_daycares to surface specifics.
| Name | Required | Description | Default |
|---|---|---|---|
| slug | Yes | Daycare slug from search_daycares results. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses that capacity by age band is only present 'when the daycare has filled it in', a key behavioral detail. Without annotations, the description carries full burden; it adequately covers the read nature but could mention response structure or pagination implications, though none apply here.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two punchy sentences: first states purpose and key data, second gives usage guidance. No wasted words; front-loaded with essential action and resource.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite lacking output schema, the description explains the return includes 'full details' and lists capacity fields. Combined with usage order hint, it provides sufficient context for correct invocation and interpretation for a simple get operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The sole parameter 'slug' is described as 'Daycare slug from search_daycares results', adding practical context beyond the schema's own description. This clarifies the source and expected format, fully leveraging schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states 'Get full details for a single daycare by slug', specifying the verb, resource, and unique identifying field. Differentiates from sibling tools like 'search_daycares' by emphasizing singular detail retrieval rather than list search.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly instructs 'Use after `search_daycares` to surface specifics', providing clear context for when to apply this tool versus alternatives like 'search_daycares' or 'daycare_capacity'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_eventAInspectGet full details for a single event by slug. Use after list_upcoming_events.
| Name | Required | Description | Default |
|---|---|---|---|
| slug | Yes | Event slug. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; description implies a safe read operation ('get full details'). Lacks disclosure of authentication requirements, rate limits, or what 'full details' entails. Adequate for a simple get but could be more explicit.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no wasted words. Front-loaded with action and resource, followed by usage hint.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple retrieval tool with one parameter and no output schema, description provides enough context: identifies input and workflow. Could mention error handling or return behavior, but not critical.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Single parameter 'slug' is described in schema as 'Event slug.' Tool description adds 'by slug' which is redundant. Schema coverage is 100%, so description adds minimal extra meaning.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states verb 'get', resource 'event', and identifier 'slug'. It distinguishes from sibling tools like list_upcoming_events by specifying this retrieves full details for a single event.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly advises to use after list_upcoming_events, indicating a clear workflow. However, it does not mention when not to use or provide alternative tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_guideAInspectFetch the full markdown body of a published editorial guide by slug.
| Name | Required | Description | Default |
|---|---|---|---|
| slug | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist. Description states it fetches markdown body of a published guide, but does not disclose authentication requirements, error behavior for missing slug, or read-only nature. Minimal behavioral disclosure beyond the action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence of 12 words, perfectly concise and front-loaded with key information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (1 param, no output schema), the description covers the essential purpose and parameter. Could optionally mention return value format (markdown string), but not severely lacking.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 0% description coverage. Description adds 'markdown body' and 'published' context but does not elaborate on the slug parameter's format or origin (e.g., from list_guides). Partial compensation only.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description uses a specific verb ('Fetch') and resource ('full markdown body of a published editorial guide'), plus identifier ('by slug'), clearly distinguishing it from sibling tools like list_guides.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit when-to-use or alternatives are provided, but the context is clear: use when you have a slug to retrieve a guide. It does not mention alternatives like list_guides for listing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_programAInspectGet full details for a single program by slug. Use this after search_programs returned a result and the user wants to know more — full description, schedule, registration timing, contact info.
| Name | Required | Description | Default |
|---|---|---|---|
| slug | Yes | Program slug from search_programs results (e.g. 'lodi-fc-competitive-soccer'). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; description only states it returns 'full details' without disclosing authentication needs, error handling, or side effects. Minimal behavioral transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded, no redundant information. Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Describes return content (full description, schedule, registration timing, contact info) which is adequate given no output schema. Lacks details on error cases or missing programs, but acceptable for a simple retrieval tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers 100% of parameter 'slug' with clear description and example. Tool description adds no additional semantic value beyond the schema, meeting baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states verb 'Get full details' and resource 'single program by slug'. Distinguishes from sibling 'search_programs' by specifying post-search usage.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly advises using after 'search_programs' results, providing clear context. Does not specify when not to use or list alternatives, but sufficient for typical use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_categoriesAInspectReturns the distinct program categories currently active in the LKA directory (e.g. Sports, Music, Arts, Academics, Swimming, Dance). Use this before search_programs to suggest exact category strings.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description bears the burden. It states the tool returns data but does not explicitly confirm it is read-only, non-destructive, or free of side effects. However, for a zero-parameter list tool, the risk is low, and the description adequately implies a safe operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the action, no filler. Every word serves a purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple zero-parameter tool with no output schema, the description is sufficient: it explains what it returns and how to use it. Could optionally mention output format (list of strings), but not necessary given the clarity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are no parameters, and schema coverage is 100%. The description adds value by explaining what the categories are and providing usage context (e.g., 'suggest exact category strings'), going beyond the bare schema information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns distinct program categories, gives concrete examples (Sports, Music, Arts), and specifies the source (LKA directory). The verb 'returns' and resource 'program categories' make the purpose explicit and distinct from sibling tools that search or manage data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly advises using this tool before search_programs to suggest exact category strings, providing clear context. No exclusions or alternatives are mentioned, but the guidance is direct and actionable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_citiesAInspectReturns the cities Lodi Kids Activities currently serves. Today: Lodi, CA only. Other cities are seeded but inactive; do not surface as active to users.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses that there are seeded inactive cities and that they should not be presented as active to users. This is sufficient transparency for a read-only list tool, though it doesn't mention return format or pagination.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the main purpose, then adding nuance about inactive cities. Every sentence is necessary and compact, with no waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no parameters and no output schema, the description is complete. It tells what the tool returns, the current state, and a behavioral constraint. No additional information is needed for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With zero parameters and schema coverage at 100%, the baseline is 4. The description adds meaning by explaining the content of the return value (active vs. inactive cities), which goes beyond the empty schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns the cities Lodi Kids Activities serves, specifying that only Lodi, CA is active and other cities are seeded but inactive. This is a specific verb-resource combination that distinguishes it from sibling tools, none of which appear to list cities.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says 'Today: Lodi, CA only' and instructs not to surface other cities as active. This provides clear guidance on when to use the tool and what to do with the results, though it does not name alternative tools for related tasks.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_guidesBInspectLists editorial guides published on LKA — parent-facing articles like 'How to pick a summer camp,' 'Lodi after-school programs by neighborhood,' etc. Useful when a parent is researching a topic rather than searching a specific program.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description should compensate by disclosing behavioral traits (e.g., read-only, permissions, rate limits). It only describes the content type, not any behavioral aspects beyond listing.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with an example, front-loading the purpose. It is concise with no wasted words, though it could be slightly more structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has one optional parameter and no output schema, the description provides sufficient context about what it lists, but it omits details like pagination, ordering, or output format.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The only parameter (limit) has 0% schema description coverage, and the description does not mention or explain the parameter at all. It fails to add meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists editorial guides on LKA, with concrete examples ('How to pick a summer camp'). It is distinct from sibling tools like get_guide, list_categories, etc., providing a specific verb and resource.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives a usage context ('when a parent is researching a topic rather than searching a specific program') but does not explicitly state when not to use it or mention alternatives like get_guide for detailed viewing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_reviewsAInspectPublic reviews for a program or daycare. Returns rating, text, reviewer first name only, season. Used by AIs to surface parent sentiment when recommending a program.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| daycare_slug | No | ||
| program_slug | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It states it returns public reviews with specific fields, but does not disclose ordering, pagination (only limit parameter), or behavior when both slugs are provided. It implies both daycare_slug and program_slug are optional, but does not clarify if one is required or how they interact.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no fluff. The first describes what it returns, the second gives usage context. Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple public read tool with no output schema and minimal parameters, the description is adequate but misses key details like filtering logic (which slug to provide?), ordering, and whether results are paginated beyond the limit parameter.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0% (no descriptions in schema). The description mentions 'program or daycare' but does not map daycare_slug and program_slug to these concepts or explain their relationship (e.g., exclusive, both required). It fails to compensate for the lack of schema documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns public reviews for a program or daycare, listing specific fields (rating, text, reviewer first name, season). It also mentions its use case (surfacing parent sentiment). This distinguishes it from sibling tools like parent_my_reviews (own reviews) and admin tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context: 'Used by AIs to surface parent sentiment when recommending a program.' This implies when to use. However, it does not explicitly state when not to use or provide alternatives, though the sibling list suggests many admin/personal tools from which this is distinct.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_upcoming_eventsAInspectList upcoming family events in Lodi, CA — open houses, workshops, community days, storytimes, sports clinics. Different from search_programs (ongoing classes) — these are single-day or short-window events.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max events to return (1-30). Default 10. | |
| category | No | Filter by event category: workshop, open_house, community, showcase, fundraiser, camp_session, storytime, sports_clinic. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses the tool lists events and mentions filter availability, but does not specify read-only nature, ordering, pagination, or any safety/reversibility aspects. Minimal behavioral insight.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no unnecessary words. Front-loaded with the main purpose and includes a crucial sibling distinction. Highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool with 2 optional parameters and no output schema, the description covers the domain, scope, and example categories. Minor gap: default limit and ordering (likely chronological) are not mentioned, but overall it is adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with descriptions for both `limit` and `category`. The description does not add significant meaning beyond the schema; it mentions event types but not parameter-specific details. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states the tool lists upcoming family events in Lodi, CA, with specific examples (open houses, workshops, etc.). Explicitly distinguishes from sibling tool `search_programs` by noting these are single-day or short-window events, not ongoing classes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides a clear distinction from `search_programs`, indicating when to use this tool versus that alternative. However, no explicit when-not-to-use or other exclusions beyond that single comparison.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
nearby_programsAInspectPrograms within a radius (miles) of a lat/lng point. Useful for AIs answering 'what's near 95240' style questions. Uses naive Haversine — accurate enough for a single city.
| Name | Required | Description | Default |
|---|---|---|---|
| lat | Yes | ||
| lng | Yes | ||
| limit | No | ||
| radius_miles | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden. It discloses the use of naive Haversine and accuracy for single city, but does not cover behavior like empty results, pagination, or rate limits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no fluff, directly addresses purpose and key behavior. Perfectly concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple 4-param tool with no output schema, the description covers core functionality and adds accuracy note. Lacks mention of optional parameters defaults, but adequate overall.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so description must add meaning. It mentions 'radius (miles)' but does not explain lat, lng, or limit parameters beyond what is inferable from names. Some value added but incomplete.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it returns programs within a radius of a lat/lng point, with explicit mention of 'what's near 95240' style questions. It distinguishes itself from sibling tools like search_programs by focusing on location-based proximity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for location-based queries and mentions accuracy, but does not explicitly state when to use this tool vs alternatives like search_programs. No 'when not to use' guidance is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
org_add_program_eventCInspectAdd a single event (practice, game, scrimmage, picture day, cancellation, etc.) to a program's calendar.
| Name | Required | Description | Default |
|---|---|---|---|
| kind | Yes | ||
| notes | No | ||
| address | No | ||
| ends_at | No | ||
| location | No | ||
| opponent | No | ||
| starts_at | Yes | ISO 8601 timestamp | |
| program_id | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description should disclose behaviors. It only states the action without mentioning side effects, permissions required, or error conditions (e.g., missing program_id).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with no filler, but it could be slightly expanded to include essential context without losing conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 8 parameters, no output schema, and no annotations. The description provides minimal context about return values, prerequisites, or usage scenarios, leaving significant gaps for the AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is very low (13%), yet the description only hints at the 'kind' parameter via examples. Other parameters like 'notes', 'address', 'ends_at', 'location', 'opponent', and 'program_id' lack any added meaning or format guidance.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Add') and the resource ('a single event'), lists examples of event kinds, and distinguishes from sibling tools like org_cancel_program_event and org_list_program_events.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not provide guidance on when to use this tool versus alternatives, such as when to add vs. cancel events. No context about prerequisites or exclusions is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
org_analyticsCInspectOrg-level analytics — page views, saves, contacts in a date window.
| Name | Required | Description | Default |
|---|---|---|---|
| days | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions metrics and date window but lacks details about read-only behavior, defaults, output format, or side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence front-loading key information. It is efficient, though adding parameter details would improve it without harming conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given one parameter, no output schema, and no annotations, the description should fully cover behavior. It lists metrics but omits defaults, output structure, and parameter semantics, leaving gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The only parameter ('days') is not described in the description. Schema description coverage is 0%, and the description does not clarify how the parameter affects the result beyond implying a date window.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it provides org-level analytics with specific metrics (page views, saves, contacts) within a date window. However, it does not differentiate this tool from the many sibling admin analytics tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like admin_cost_summary or admin_live_activity. No exclusions or context for usage are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
org_archive_programAInspectSoft-archive a program (active=false). Hides from public directory but preserves history.
| Name | Required | Description | Default |
|---|---|---|---|
| program_id | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses that the operation is non-destructive (soft-archive), sets active=false, hides from public directory, and preserves history. This is sufficient for a simple mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the action, no fluff. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and a single parameter, the description adequately explains the tool's effect. However, it does not mention return values or success conditions, which would be helpful for a mutation tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, yet the description does not explain the program_id parameter. While the parameter name is self-explanatory, the description should ideally clarify it. It adds no meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (soft-archive), the resource (program), and the effect (active=false, hides from public directory but preserves history). It distinguishes from siblings like org_update_program by specializing in archiving.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the use case (hiding a program without deleting) but does not explicitly mention when not to use it or compare to alternatives like org_update_program. Context is clear but lacks exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
org_cancel_program_eventBInspectMark a program event as canceled. Enrolled parents see this in their hub + iCal.
| Name | Required | Description | Default |
|---|---|---|---|
| reason | No | ||
| event_id | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; description discloses that cancellation is visible in hub and iCal, but does not mention reversibility, permissions, or other side effects. Adequate but lacks depth.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, front-loaded with purpose; no unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given a mutation tool with no output schema and no parameter descriptions, the description is missing important details like required permissions, response format, and parameter syntax. However, for a simple cancellation it is somewhat adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 0% description coverage; the description does not mention any parameter names or provide context for event_id or reason. No added meaning.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clear verb 'Mark as canceled' on 'program event'; distinguishes from sibling tools like org_add_program_event. Also states effect on enrolled parents.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Description provides context that cancellation is visible to parents, but does not explicitly state when to use vs other tools (e.g., no mention of alternatives or when not to use).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
org_confirm_listing_freshAInspectConfirm a program listing is still accurate (resets the stale-nudge timer).
| Name | Required | Description | Default |
|---|---|---|---|
| program_id | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds behavioral insight beyond the schema by explaining the effect on the stale-nudge timer, which is helpful given no annotations are provided. It does not detail all side effects but is adequate for a simple confirmation action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, focused sentence that front-loads the main action and outcome with no unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one parameter, no output schema), the description covers the essential purpose and effect completely, leaving no critical gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description does not explicitly describe the program_id parameter, but the parameter name and tool context make its purpose clear. With 0% schema description coverage, the description partially compensates due to simplicity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses specific verb 'Confirm' and resource 'program listing', clearly indicating the action of verifying accuracy and resetting a timer, which differentiates it from sibling tools like org_update_program or org_archive_program.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use the tool (to confirm accuracy and reset stale-nudge timer), but does not explicitly state when not to use it or mention alternatives, though the context is strong.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
org_dashboardAInspectOrg dashboard summary — program count, leads in last 7d, new saves in last 7d, listing-status breakdown.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully disclose behavior. It mentions the data included (program count, leads, saves, listing-status breakdown), but does not specify whether the data is real-time, cached, or requires any particular permissions. For a data retrieval tool, this is adequate but could be improved.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that efficiently communicates the tool's purpose and key outputs without any extraneous information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no parameters and no output schema, the description adequately lists the four metrics returned. However, it does not specify the response format (e.g., JSON structure), which would improve completeness for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and the input schema is fully covered (100%). With no parameters to document, the description adds no additional parameter semantics, but this is acceptable as there is nothing to add.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it provides an org dashboard summary with specific metrics: program count, leads in last 7d, new saves in last 7d, and listing-status breakdown. This verb+resource combination distinguishes it from sibling tools like admin_cost_summary or admin_live_activity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for obtaining an overview of org performance, but does not explicitly state when to use it over alternatives, nor does it provide exclusions or prerequisites. Sibling tools exist, but no guidance is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
org_generate_promo_kit_urlCInspectReturns a URL to the org's downloadable promo kit (QR poster + share card) for a given program.
| Name | Required | Description | Default |
|---|---|---|---|
| program_id | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description must disclose behavioral traits. It only states the output is a URL, without mentioning authentication requirements, error handling, rate limits, or side effects. This is insufficient for safe invocation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that front-loads the purpose. However, it omits important details such as parameter clarification and behavioral notes, making it only minimally adequate.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (1 parameter, no output schema), the description is minimally complete. It conveys the core functionality but lacks error handling notes, usage precautions, and alternative tool references.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has one parameter (program_id) with 0% description coverage. The description merely says 'for a given program' without explaining the format, source, or constraints of program_id. It adds minimal value beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Returns a URL to the org's downloadable promo kit (QR poster + share card) for a given program,' specifying the verb, resource, and scope. However, it does not differentiate from sibling tools, which lack similar functionality.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives. No prerequisites, exclusions, or context for invocation are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
org_list_leadsBInspectReturns recent daycare leads + program saves for the org.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It only says 'Returns...' with no mention of data freshness limits, authentication requirements, or whether the action is read-only. This is insufficient for a safe tool invocation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single focused sentence with no redundant information. It is efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no parameters and no output schema, the description is minimally adequate. However, it could mention the ordering or time range of 'recent', making it more complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With zero parameters, the schema coverage is 100%. The description adds value by naming the specific data returned ('leads' and 'saves'), which goes beyond the empty schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it returns 'daycare leads' and 'program saves', specifying the resource and action. However, it does not differentiate from sibling tools that might also return lists, such as parent_list_saves or parent_list_enrollments.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. It lacks context about the intended scenario or prerequisites, leaving the agent without direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
org_list_program_eventsCInspectList upcoming events for a program owned by this org.
| Name | Required | Description | Default |
|---|---|---|---|
| days_ahead | No | ||
| program_id | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. Does not disclose behavior such as ordering, pagination, error handling, or what 'upcoming' specifically means. Lacks details on side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence with no fluff, but it comes at the cost of missing crucial information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema, no annotations, and minimal description. For a tool with two parameters, the description is insufficient to fully understand usage or return value.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%; description does not explain that 'days_ahead' filters the range or that 'program_id' identifies the program. Adds no meaning beyond parameter names.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states verb 'List' and resource 'upcoming events for a program owned by this org', distinguishing it from tool siblings like org_add_program_event (add) and list_upcoming_events (different scope).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool vs alternatives like list_upcoming_events or program_events_feed. No prerequisites or conditions mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
org_list_programsCInspectReturns the org's programs.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided. The description does not disclose behavioral traits such as authentication requirements, rate limits, or side effects. For a read operation, the description only states 'returns' without confirming it's safe or read-only.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no unnecessary words, achieving maximum conciseness for the amount of information provided.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is very brief and lacks completeness for a list tool. It does not mention pagination, output format, or what constitutes a 'program' in this context. Given no output schema or annotations, the description should provide more context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema is empty with 100% coverage, so no parameter documentation is needed. The description does not add any additional meaning beyond the schema, meeting the baseline for zero parameters but not enriching understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Returns the org's programs' clearly states the action (returns) and the resource (org's programs), distinguishing from sibling tools like search_programs and get_program by implying a complete list. However, it could be more specific about the scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool vs. alternatives like search_programs or get_program. No mention of prerequisites or limitations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
org_reply_to_reviewBInspectPost an org response to a review. Requires consent. Replies are one-shot per review.
| Name | Required | Description | Default |
|---|---|---|---|
| review_id | Yes | ||
| response_text | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description reveals two key behaviors: consent requirement and one-shot limitation. However, it lacks details on side effects, error states, or what happens if consent is not obtained.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three short sentences, front-loading the purpose and adding constraints succinctly with no waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple mutation tool with 2 parameters and no output schema, the description covers the core purpose and key constraints but could mention return value or common errors to fully guide the agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and the description adds no meaning beyond the parameter names (review_id, response_text). It does not explain formats, constraints, or relationships.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'Post an org response to a review' with a specific verb and resource, clearly differentiating from sibling tools like parent_submit_review and list_reviews.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description notes 'Requires consent' and 'Replies are one-shot per review', providing context on prerequisites and constraints. However, it does not specify when to use this tool versus alternatives or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
org_update_profileCInspectUpdate the org's profile (website, phone, email, logo_url, instagram).
| Name | Required | Description | Default |
|---|---|---|---|
| No | |||
| phone | No | ||
| website | No | ||
| logo_url | No | ||
| No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description should disclose behavioral traits like permissions needed, side effects (e.g., overwrites vs merges), and idempotency. It only states 'update', which implies mutation, but provides no further behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, efficiently conveying the action and fields. However, it could benefit from additional structure, such as a separate sentence for behavioral details, without losing conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, no annotations, and five parameters with 0% schema coverage, the description should provide complete context. It lacks details on return values, error conditions, update behavior, and prerequisites, making it insufficient for a mutation tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate by explaining parameter semantics. It merely lists the parameter names (website, phone, etc.) without any format, constraints, or usage guidance. This is insufficient for proper invocation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action 'update' and the resource 'org profile', listing the specific fields (website, phone, email, logo_url, instagram). It distinguishes from sibling tools which involve different resources or actions (e.g., org_analytics, parent tools). However, it does not specify whether this is a partial or full update.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus alternatives, no prerequisites, and no mention of when not to use it. The description lacks context for appropriate invocation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
org_update_programCInspectUpdate an existing program's editable fields.
| Name | Required | Description | Default |
|---|---|---|---|
| day | No | ||
| cost | No | ||
| name | No | ||
| time | No | ||
| season | No | ||
| address | No | ||
| age_max | No | ||
| age_min | No | ||
| cost_num | No | ||
| location | No | ||
| program_id | Yes | ||
| description | No | ||
| listing_status | No | ||
| openings_remaining | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full behavioral disclosure burden. It only mentions 'update' implying mutation, but does not disclose idempotency, authorization requirements, error handling, or effects on related data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very concise at one sentence, but is too sparse for the complexity of the tool. It sacrifices completeness for brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 14 parameters, no output schema, and no annotations, the description is grossly insufficient. It does not explain return values, error conditions, or parameter relationships.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description must compensate, but it merely says 'editable fields' without specifying which of the 14 parameters are editable or providing any additional meaning beyond the parameter names and types.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Update' and the resource 'existing program', and specifies scope 'editable fields'. It distinguishes from sibling tools like org_update_program_capacity and org_archive_program, which focus on narrower aspects.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives such as org_update_program_capacity (for capacity only) or org_archive_program (for archiving). No when-not or prerequisite information is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
org_update_program_capacityAInspectSet the listing status on a program (accepting / full / waitlist_only / closed_for_season). Requires consent.
| Name | Required | Description | Default |
|---|---|---|---|
| program_id | Yes | ||
| listing_status | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses that consent is required, which is a key behavioral trait. However, with no annotations provided, it does not cover potential side effects, scope of changes, or whether the operation is reversible.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, front-loaded with the action and allowed values. Every word earns its place without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Adequate for a simple mutation tool with two parameters, but lacks details on return value, confirmation, or how to obtain consent. Without annotations or output schema, more context would be beneficial.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Adds meaning by enumerating the valid listing_status values and mentioning consent, but does not explain program_id beyond its schema definition. With 0% schema description coverage, it partially compensates but remains incomplete.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly specifies the action (set the listing status) and the resource (a program). Lists the exact allowed values, distinguishing it from sibling tools like org_update_program or org_archive_program.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides no explicit guidance on when to use this tool versus alternatives. However, the purpose is specific enough that an agent can infer it is for changing capacity status, but exclusion conditions are missing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
parent_accept_household_inviteBInspectAccept a household invite using the token from the invite link.
| Name | Required | Description | Default |
|---|---|---|---|
| token | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full responsibility for behavioral disclosure. It only states the basic action without detailing consequences (e.g., adding the user to the household), error cases (e.g., invalid or expired token), or side effects. Important behavioral aspects are omitted.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, focused sentence with no extraneous information. It is appropriately concise for a simple tool, and all words add value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simplicity of the tool (one parameter, no output schema), the description is minimally adequate. However, it does not cover what happens after successful acceptance, error handling, or prerequisites for use. A more complete description would mention the expected outcome and possible failure modes.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema describes a single 'token' parameter with no description (0% coverage). The description adds context by stating that the token comes from the invite link, which helps an agent understand the source of the value. However, it remains vague and does not specify whether the token is the full link or just a code, nor its format.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (accept), the target (household invite), and the method (using the token from the invite link). It effectively distinguishes from sibling tools such as parent_invite_household_member and parent_leave_household by specifying the invite acceptance action.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description lacks any guidance on when to use this tool versus alternatives. No prerequisites, conditions, or exclusions are mentioned. For example, it does not clarify that the user must have received an invite and have the token, nor does it reference related tools like parent_my_household for verification.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
parent_add_kidBInspectAdd a kid to the parent's account. Requires consent.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | ||
| birthdate | No | YYYY-MM-DD | |
| interests | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry full transparency burden. It discloses that consent is needed, but fails to mention side effects (e.g., creation of a record), required authentication, or return behavior. The short description offers minimal insight into the tool's behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is extremely concise (two sentences) and front-loaded with the core action. However, given the tool's complexity and lack of schema documentation, it may be too terse. Still, it avoids verbosity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 3 parameters, no output schema, and no annotations, the description should provide richer context. It does not explain the consent mechanism, what the tool returns, or how interests are used. The sibling tools (e.g., parent_list_kids, parent_remove_kid) imply a lifecycle but are not referenced.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 33% (only birthdate has a format hint), and the tool description adds no meaning for any parameter. The agent receives no guidance on what 'name', 'birthdate', or 'interests' represent or how to format them. This severely impairs correct parameter usage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states verb 'Add' and resource 'kid to the parent's account', distinguishing it from sibling tools like parent_remove_kid and parent_update_kid. The action is unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Mentions 'Requires consent' as a prerequisite but provides no explicit guidance on when to use versus alternatives (e.g., parent_update_kid). The usage context is implied but lacks exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
parent_calendar_subscribe_urlAInspectReturns the parent's personal iCal feed URL — subscribe in Google/Apple/Outlook Calendar to see practices + games in your normal calendar app. Refreshes hourly.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description correctly identifies the tool as returning a URL (read-only) and mentions that the feed refreshes hourly. This is a key behavioral trait. It does not cover authentication requirements, but the name prefix 'parent_' implies authenticated access, which is acceptable. No contradictions with annotations (none provided).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description consists of two sentences, both front-loaded: the first sentence states the core purpose and output, the second provides additional behavioral detail (refresh rate). No extraneous text, every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (no parameters, no output schema), the description is fully complete. It covers what the tool returns, its purpose, how to use it (subscribe in calendar apps), and a key behavior (hourly refresh). No gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has no parameters, so there is nothing to explain. Per calibration baseline for 0 parameters, a score of 4 is appropriate since the description does not need to add parameter semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns the parent's personal iCal feed URL for subscribing to calendar events (practices and games). It uses specific verbs ('returns', 'subscribe') and resource ('iCal feed URL'), distinguishing it from sibling tools like parent_my_upcoming_events which list events in-app.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explains when to use the tool (to see practices/games in a normal calendar app via subscription) and mentions compatible calendars (Google/Apple/Outlook). However, it does not explicitly state when not to use it or provide alternatives like parent_my_upcoming_events, which might be used for a one-time view without subscription.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
parent_cancel_tourBInspectCancel a tour request you previously submitted.
| Name | Required | Description | Default |
|---|---|---|---|
| tour_id | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must cover behavioral traits. It only says 'Cancel' without disclosing effects (e.g., irrevocable, requires the tour to be in a cancellable state, authorization needs). This is insufficient for an agent to understand consequences.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One short sentence with no fluff, but it is under-specified. Conciseness is good, but the lack of necessary detail prevents a higher score.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple cancel action, the description omits key context: whether cancellation is reversible, if the tour must be in a specific state (e.g., not yet occurred), and what the response looks like. Insufficient for an agent to reliably invoke the tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The single parameter 'tour_id' has no description in the schema (0% coverage). The description adds no meaning about where to obtain the ID, its format, or constraints. Minimal value beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action 'Cancel' and the resource 'a tour request', matching the tool name. It distinguishes from siblings like 'parent_request_tour' (create) and 'daycare_respond_to_tour' (different actor).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use for tours you previously submitted, but no explicit guidance when to use vs alternatives, nor any exclusions or prerequisites. Given many sibling tools, this is a gap.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
parent_export_my_dataAInspectExport everything LKA has on you in a single JSON payload (kids, saves, enrollments, tours, reviews, household membership).
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose any behavioral traits such as whether it's read-only, authentication requirements, rate limits, or potential performance impact. It only describes the output.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that efficiently communicates the purpose and content without any extraneous information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given there is no output schema, the description adequately lists the data categories included in the export, but could be more complete by indicating the structure (e.g., 'JSON object with keys: kids, saves...'). Still sufficient for a simple tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With zero parameters, the baseline is 4. The description adds value by specifying the content of the returned payload (kids, saves, etc.), which is not present in the empty input schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Export' and the resource 'everything LKA has on you', listing specific data types, which distinguishes it from sibling tools that export partial data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for bulk export, but does not explicitly state when to use this tool over other more specific export tools (e.g., parent_list_kids) nor any prerequisites or limitations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
parent_invite_household_memberAInspectInvite a co-parent / partner / grandparent to share this household. They receive a one-time invite link by email; on accept, they join the household and can see all kids + saves.
| Name | Required | Description | Default |
|---|---|---|---|
| Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, description discloses invite delivery (email, one-time link) and access granted (see all kids + saves). Good coverage of behavioral outcome, though could mention expiration or limits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no redundant information. Efficiently communicates purpose, mechanism, and outcome.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Adequate for a simple trigger action with one parameter and no output schema. Explains process but lacks error scenarios (e.g., invalid email, already a member).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Only one parameter (email) with 0% schema description coverage. Description implies it's the invitee's email but does not explicitly clarify parameter semantics beyond the schema. Minimal added value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states the action (invite), target (co-parent/partner/grandparent), mechanism (one-time invite link by email), and outcome (join household, see all kids + saves). Distinct from sibling tool 'parent_accept_household_invite'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Implies usage (when adding a co-parent) but no explicit guidance on when to use versus alternatives like 'parent_accept_household_invite' or 'parent_leave_household'. Missing exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
parent_leave_householdAInspectLeave the current household. If you're the owner and there are other members, ownership transfers to the longest-tenured member.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It explains ownership transfer, but lacks details on side effects (e.g., access loss, reversibility).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the main action, no unnecessary information. Efficient and clear.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with no parameters, the description covers the action and a key nuance (ownership transfer) adequately for an agent to invoke correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist (0 params), so baseline 4 applies. The description does not need to add param meaning.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Leave the current household') and explains the ownership transfer rule, distinguishing it from household-related siblings like parent_accept_household_invite.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear context (when to leave a household) and the ownership transfer behavior, but does not explicitly state when not to use or compare to alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
parent_list_enrollmentsBInspectReturns the parent's enrollments (programs their kid is signed up for).
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden of behavioral disclosure. It merely states that enrollments are returned, without mentioning authentication requirements, scope (current parent only), or that the operation is read-only and safe.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that is front-loaded and includes a parenthetical clarification. It is concise and clear.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no parameters and no output schema, the description is minimally adequate. However, it lacks details on the structure of the return (e.g., list format, pagination, or what fields are included). Given the sibling tools' complexity, it could be more informative.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters with 100% coverage. Per guidelines, a baseline of 4 is appropriate. The description adds value by explaining the return value context, even though no parameters exist.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Returns' and a clear resource 'parent's enrollments' with a clarifying parenthetical 'programs their kid is signed up for'. It distinctly differentiates from sibling tools such as parent_my_applications and parent_my_waitlist_positions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like parent_my_applications or parent_list_tours. There is no mention of prerequisites, context, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
parent_list_kidsAInspectReturns the parent's kids on file (names + ages, no PII beyond what they shared).
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries the full burden. It discloses that only non-PII data (names and ages) is returned, and notes the 'no PII beyond what they shared' privacy qualification. It does not mention error handling or edge cases, but for a simple read operation, the description is adequately transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single 15-word sentence that front-loads the primary action and includes a parenthetical with key details. Every word adds value, and there is no redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple retrieval tool with no parameters and no output schema, the description covers the core functionality (returning names and ages) and adds a privacy note. It could specify the output format more precisely (e.g., array of objects) but is sufficient for the complexity level.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has no parameters and schema description coverage is 100% (empty). Baseline is 3 per rubric. The description adds no additional parameter information because there are none.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Returns', the resource 'parent's kids on file', and explicitly lists the data returned ('names + ages') with a privacy caveat. It distinguishes from sibling write/delete tools like parent_add_kid and parent_remove_kid.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when you want to view a parent's kids, but provides no explicit guidance on when to use this tool vs alternatives (e.g., parent_my_household might also list kids). No 'when not to use' or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
parent_list_savesAInspectReturns the signed-in parent's saved (hearted) programs AND daycares. Each row has a kind field of 'program' or 'daycare' so callers can route to the right detail page. Previously this tool returned {program_id: null} for daycare rows with no other data — a hangover from when only programs could be saved.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully disclose behavior. It mentions the kind field and a historical bug, but fails to state permissions, idempotency, rate limits, or return size limits. The description lacks sufficient behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences: first states the core function, second adds detail about the kind field and historical fix. The historical mention is slightly extraneous but does not harm conciseness. It is front-loaded and efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and no annotations, the description is somewhat complete but lacks key details like pagination, result ordering, error conditions, and potential empty results. A minimal description for a list endpoint should address these.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are no parameters (schema coverage 100%), so the description adds all semantic meaning about the output structure. It explains the kind field and routing usage, which goes beyond the schema's empty definition.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool 'returns the signed-in parent's saved (hearted) programs AND daycares', specifying the resource and action. It distinguishes from sibling tools like parent_save_daycare and parent_save_program, which are actions to save, not list.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for listing saved items, but does not explicitly state when to use this tool versus alternatives like parent_list_enrollments or parent_my_applications. No when-not or exclusion criteria are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
parent_list_toursAInspectReturns the parent's daycare tour requests with status.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Description is minimal, only stating it returns data. No disclosure of side effects, authentication needs, rate limits, or output format. Since no annotations are provided, the description carries full burden but adds little beyond the basic function.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, no wasted words, clearly front-loaded with the action and resource.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Adequately covers the purpose for a simple read tool with no parameters, but lacks details like sorting, status meanings, or explanation of tour request lifecycle that could be helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist, so schema coverage is 100%. Description doesn't need to add parameter info. Baseline of 4 is appropriate as it doesn't miss anything.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it 'returns the parent's daycare tour requests with status', specifying the verb, resource, and included field. It distinguishes from sibling tools like parent_request_tour (create) and daycare_list_tours (daycare perspective).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives such as parent_request_tour or parent_cancel_tour. No exclusions or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
parent_meAInspectReturns the signed-in parent's profile + preferences.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It does not disclose authentication requirements, side effects, or rate limits. For a read-only tool, minimal behavioral info is given.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, front-loaded with action. No wasted words, but could include a note about authentication or response scope.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Sufficient for a simple 0-parameter retrieval tool. Specifies what is returned (profile + preferences) and the context (signed-in parent). No output schema needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist (schema coverage 100% empty). Description adds no parameter info as none are needed, baseline 4 for 0 parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states verb 'Returns' and resource 'signed-in parent's profile + preferences', making the purpose unambiguous. It distinguishes from sibling tools like 'parent_my_household' which returns household info.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus siblings. Usage is implied as retrieving current parent data, but no exclusions or alternatives are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
parent_my_applicationsCInspectDaycare applications the parent has submitted.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behaviors. It only states what is returned, omitting whether the operation is read-only, requires authentication, or has any side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence with no unnecessary words. However, it is a noun phrase rather than a complete imperative, which slightly reduces clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description should explain the return structure more thoroughly. It merely states 'applications' without details on fields, sorting, or pagination.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are no parameters, so the schema coverage is 100%. The description adds value by clarifying the output context (daycare applications), which exceeds the schema's empty definition.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Daycare applications the parent has submitted' indicates the tool lists applications, but it's a noun phrase rather than a clear verb+resource statement. It is distinguishable from sibling tools like parent_list_enrollments, but lacks specificity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as parent_list_enrollments or parent_list_tours. The description offers no context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
parent_my_householdAInspectReturns the parent's household members + shared kids. If no household exists yet, returns null.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It discloses the main behavior (return data or null) but does not mention idempotency, side effects, or permissions. Minimal but not misleading.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is a single sentence with two clauses, no fluff. It front-loads the main action and includes the edge case (null). Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given zero parameters and no output schema, the description provides essential behavior and a null edge case. It is nearly complete, though details on the structure of returned data (e.g., format of household members) would improve it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist and schema coverage is 100% (empty schema). Baseline for 0 params is 4. Description adds context about return values (members + shared kids) which is helpful but not required for parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it returns the parent's household members and shared kids, and specifies the null case. This distinguishes it from sibling tools like parent_invite_household_member (action) and parent_me (different resource).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use for retrieving household data, but lacks explicit guidance on when to use versus alternatives like parent_accept_household_invite or parent_leave_household. No exclusions or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
parent_my_reviewsCInspectReviews the parent has submitted.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, and the description only states it returns reviews. It does not disclose any behavioral traits such as pagination, sorting, or permission requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that is front-loaded and to the point. It wastes no words, though it is minimal.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Lacking output schema and annotations, the description fails to explain the format, ordering, or any limitations of the returned reviews. This leaves the agent without sufficient context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0 parameters and 100% schema coverage, the baseline is 3. The description adds value by indicating the tool uses the authenticated parent's identity, but does not provide extra detail beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states that the tool retrieves reviews submitted by the parent. It is specific and distinguishes itself from sibling tools like 'list_reviews' and 'parent_submit_review'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. There is no mention of context, prerequisites, or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
parent_my_upcoming_eventsBInspectUpcoming program events (practices, games, scrimmages) for the parent's enrolled programs. Covers next 30 days by default. Cancellations included as 'canceled' status.
| Name | Required | Description | Default |
|---|---|---|---|
| days_ahead | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses that cancellations are included with a 'canceled' status, which is useful behavioral info. However, it does not mention sorting order, whether events include past ones within the range, or any rate limits. More detail on the data set behavior would raise the score.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences long, front-loaded with the core purpose, and contains no unnecessary words. Every sentence adds information: first defines scope and content, second clarifies default range and cancellation handling.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool is simple (one optional parameter, no output schema), the description provides enough to understand what it returns. However, it lacks details like pagination, response format, or whether events are ordered. For a complete picture, a mention of sorting or data limits would be beneficial.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, so the description must compensate. It states a default of 30 days, implying the days_ahead parameter overrides this, but does not explicitly explain the parameter's function or the effect of different values. The description adds some value but not enough for a higher score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists upcoming program events for the parent's enrolled programs, specifying event types (practices, games, scrimmages). It distinguishes itself from sibling tools like list_upcoming_events (public) and org_list_program_events (org-specific) by focusing on the parent's enrolled programs. However, it could explicitly contrast with these siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as list_upcoming_events or org_list_program_events. There is no mention of prerequisites, context, or exclusions. The description only states the default 30-day coverage but does not explain when a user might need to adjust the days_ahead parameter or consider other tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
parent_my_waitlist_positionsAInspectDaycare waitlists the parent is on, with current position.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; description is minimal and does not disclose behavioral traits such as authentication requirements, data recency, or response format. As a read operation, it could benefit from stating it returns only the parent's own data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, no redundant information. Front-loaded with purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema; description mentions 'with current position' but does not specify the structure of the response. Adequate for a simple list tool, but could be more explicit about returned fields.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist, so schema coverage is 100%. Baseline of 4 applies as there is nothing to explain.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool lists daycare waitlists a parent is on with their current position. Verb 'parent_my_waitlist_positions' and description align, and it differentiates from sibling tools like parent_list_applications or parent_list_enrollments.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool vs alternatives. Among many sibling tools (e.g., parent_list_applications, parent_list_tours), the description does not provide context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
parent_recommended_for_meBInspectPrograms matched to the parent's primary kid's age + interests. Simple matcher today — surfaces top 10 active programs that include the kid's age in their range, weighted by interest overlap.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description discloses key behaviors: it's a simple matcher, returns top 10 active programs, weighted by interest overlap. It doesn't mention side effects or auth requirements, but is fairly transparent for a read-only recommendation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences that effectively convey the tool's purpose and behavior. Could be slightly more structured but remains clear.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description adequately explains input and behavior, but lacks details on output format (e.g., which program fields are returned). Given no output schema, more completeness would be beneficial.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The only parameter 'limit' is not mentioned in the description. Schema coverage is 0%, so description should explain it. The description says 'surfaces top 10', which contradicts the adjustable limit, causing confusion.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it returns programs matched to the parent's primary kid's age and interests, and specifies 'simple matcher today' distinguishing it from more advanced search tools. However, it could more explicitly contrast with sibling tools like search_programs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied by the description (personalized recommendations for the parent's primary kid), but no explicit guidance on when to use it vs alternatives, nor any exclusion criteria or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
parent_remove_kidAInspectRemove a kid from the parent's account. Irreversible — deletes the kid record and any kid-linked enrollments/reviews remain but become orphaned (kid_id set null).
| Name | Required | Description | Default |
|---|---|---|---|
| kid_id | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description fully discloses behavioral traits: irreversible deletion, and side effects on enrollments/reviews becoming orphaned. This exceeds the minimal requirement for transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with two sentences: the first states the purpose, and the second adds critical behavioral context. No superfluous information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of an output schema, the description adequately explains the effect of the action (deletion and orphaned records). However, it does not mention what the response or confirmation will be, which is a minor gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The single parameter kid_id has no description in the schema (0% coverage), and the tool description offers no additional meaning beyond the parameter name. It does not explain how to obtain a valid kid_id or any constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool removes a kid from the parent's account with a specific verb and resource, distinguishing it from sibling tools like parent_add_kid and parent_update_kid.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description warns that the action is irreversible but does not provide explicit guidance on when to use this tool versus alternatives, nor does it mention prerequisites or context for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
parent_report_enrollmentAInspectSelf-report that the parent enrolled their kid in a program outside the LKA RegFlow ('I'm In'). Accepts program UUID or slug.
| Name | Required | Description | Default |
|---|---|---|---|
| kid_id | No | ||
| program_id | Yes | Program UUID or slug |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions a self-report action but does not disclose whether it is idempotent, requires specific authentication, or any side effects (e.g., confirmation, state changes).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no wasted words. The verb and resource are front-loaded, and the accepted parameter format is clarified. Highly concise and structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the main action and the program_id parameter, but lacks details about the optional kid_id parameter and does not mention output or side effects. Adequate for a simple tool but with notable gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 50% (kid_id lacks description). The description only adds meaning for program_id ('UUID or slug'), not for kid_id. It fails to compensate for the missing schema documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('self-report enrollment'), the resource ('parent enrolled their kid in a program'), and specifies it is for enrollments outside the LKA RegFlow, distinguishing it from internal enrollment tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides context ('outside the LKA RegFlow') implying when to use this tool versus internal enrollment, but does not explicitly state when not to use or list alternative tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
parent_request_tourCInspectSubmit a daycare tour request. Returns the tour id + status='requested'.
| Name | Required | Description | Default |
|---|---|---|---|
| notes | No | ||
| kid_id | No | ||
| daycare_id | Yes | ||
| preferred_date_1 | Yes | YYYY-MM-DD | |
| preferred_date_2 | No | ||
| start_date_needed | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It only mentions the return value but does not disclose side effects, idempotency, authentication requirements, or what happens on duplicate requests. The behavioral description is minimal.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence—no fluff, front-loaded with the main action. While it could be more structured, it earns its place by being direct.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 6 parameters, no output schema, no annotations, and low schema coverage, the description is insufficient. It fails to explain parameter semantics, required fields, or error handling, leaving the agent under-informed for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description does not explain any parameters beyond what the schema provides. Schema coverage is only 17% (only preferred_date_1 has a format hint). The description adds no value to parameter understanding, leaving the agent to guess meanings of notes, kid_id, etc.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action: 'Submit a daycare tour request' and specifies the return value (tour id + status). This distinguishes it from sibling tools like parent_cancel_tour and parent_list_tours.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool vs alternatives. It does not mention prerequisites, conditions, or exclude cases. The description lacks any context about the appropriate scenario for using this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
parent_revoke_my_tokensAInspectRevoke ALL MCP tokens issued under your parent account. Use this if you suspect an AI agent has misused your access.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. It mentions the action is revoking ALL tokens, implying destructiveness, but it does not detail side effects, irreversibility, rate limits, or what happens after revocation (e.g., need to re-authenticate). More transparency is needed for a security-sensitive operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the verb and resource, no wasted words. The description earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no parameters and no output schema, the description covers the basic purpose and usage context. However, it lacks behavioral details (e.g., confirmation, undo), making it minimally complete for a destructive action.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema has 0 parameters, so schema coverage is 100%. The description does not add parameter-level meaning (there are none), which is acceptable. However, it could have explicitly stated that no parameters are required for clarity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (revoke), the resource (MCP tokens under parent account), and the scenario (suspected misuse). It distinguishes itself from sibling tools, none of which handle token revocation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly tells when to use: 'if you suspect an AI agent has misused your access.' No alternatives are mentioned, but given sibling list, no other token revoke tool exists, so this is clear context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
parent_save_daycareCInspectSave a daycare to the parent's hub.
| Name | Required | Description | Default |
|---|---|---|---|
| daycare_id | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description carries full burden. It only says 'Save' with no details on side effects (e.g., whether duplicates are allowed, if overwriting occurs), permissions needed, or whether changes are reversible.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise (one sentence) but overly brief; it sacrifices informativeness for brevity. It could be improved with more detail without being verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one parameter), the description should be adequate but falls short. It does not explain the concept of 'saving to hub' or how the result is used, leaving the agent without full context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has one parameter (daycare_id) with 0% description coverage and no explanation in the tool description. The meaning of daycare_id and how to obtain it are not explained.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Save') and the resource ('daycare') and mentions it's scoped to the parent's hub. It distinguishes from sibling tools like parent_save_program and parent_unsave_program.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives (e.g., parent_save_program) or when not to use it. The description lacks context about prerequisites or expected outcomes.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
parent_save_programAInspectSave a program to the parent's hub. Accepts either the program UUID or its slug (e.g. 'youth-soccer-league'). Optionally associate the save with one or more specific kids (by UUID or name) so the kid filter in /account → Saved Programs picks it up. Requires consent.
| Name | Required | Description | Default |
|---|---|---|---|
| kid_ids | No | Optional: one or more kid UUIDs OR first names (case-insensitive) to tag the save with. Use parent_list_kids to look them up. | |
| program_id | Yes | Program UUID or slug |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses that consent is required, which is a key behavioral trait. However, it does not mention if the operation is idempotent or what happens on duplicate saves, leaving some gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences, front-loaded with the core action, and each sentence serves a purpose: what it does, how program_id works, optional kid_ids with benefit and consent warning. No waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the two parameters, full schema coverage, and no output schema, the description covers the essential aspects: action, parameters, and behavioral constraint (consent). It could mention return value or error cases, but that's not expected without output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with good descriptions. The tool description adds value by explaining that program_id accepts both UUID and slug (with example), and that kid_ids is for filtering in saved programs and requires consent. This context enriches the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool saves a program to the parent's hub, specifies it accepts UUID or slug, and optionally tags kids. This distinguishes it from sibling tools like parent_unsave_program and parent_save_daycare.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains when to use the kid_ids parameter and suggests using parent_list_kids for lookup. It also notes consent is required. However, it does not explicitly state when not to use this tool or provide alternatives, though siblings imply some context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
parent_submit_reviewAInspectSubmit a review for a program or daycare. One review per (parent, program). Use parent_update_review to edit afterward.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | ||
| kid_id | No | ||
| rating | Yes | ||
| season | No | ||
| daycare_id | No | ||
| program_id | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose all behavioral traits. It states the core action and the uniqueness constraint but omits details like what happens if a review already exists, required fields for specifying the program/daycare, authentication requirements, or side effects. The description is partially transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences: first states purpose, second gives usage guidance. It is concise and front-loaded with the essential information. However, it could be slightly more structured with parameter hints.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 6 parameters, no output schema, and no annotations, the description is too brief. It does not cover return values, error scenarios, or detailed parameter usage. It provides the minimum viable information but leaves many details unsaid.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must explain parameters. It mentions 'program or daycare' but does not clarify that daycare_id and program_id are optional or that one must be provided. kid_id, season, and text are not explained at all beyond the schema. The description adds little value beyond the parameter names.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Submit a review'), the target resource ('program or daycare'), and the constraint ('One review per (parent, program)'). It also distinguishes from the sibling tool 'parent_update_review' by explicitly mentioning it for edits.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly tells when to use this tool ('Submit a review') and when to use an alternative ('Use parent_update_review to edit afterward'). The one-review-per-pair constraint also informs usage. This provides clear guidance for an AI agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
parent_unsave_programAInspectRemove a saved program from the parent's hub. Accepts either the program UUID or its slug. Requires consent.
| Name | Required | Description | Default |
|---|---|---|---|
| program_id | Yes | Program UUID or slug |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears full responsibility. It discloses consent requirement and input flexibility but lacks details on side effects, reversibility, or error conditions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the action, no extraneous information. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple 1-parameter tool with no output schema, the description covers the essential aspects. Could mention it's a parent-specific operation, but the name implies that. Return value is not described, which is acceptable given no output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with a clear description matching the tool's description (UUID or slug). The description adds no new meaning beyond the schema, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Remove a saved program'), the resource ('parent's hub'), and input flexibility (UUID or slug). It distinguishes from siblings like parent_save_program.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions 'Requires consent' as a condition but does not explicitly state when to use this tool versus alternatives like parent_save_program. No when-not or alternative guidance is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
parent_update_kidBInspectUpdate a kid record (birthdate, interests, school, special_needs).
| Name | Required | Description | Default |
|---|---|---|---|
| name | No | ||
| kid_id | Yes | ||
| school | No | ||
| birthdate | No | YYYY-MM-DD | |
| interests | No | ||
| special_needs | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It indicates mutation ('update') but lacks details on authorization, side effects, error handling, or safety. The behavioral impact is minimally disclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with no redundant words. It efficiently conveys the core purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool with 6 parameters and no output schema or annotations, the description is too minimal. It does not explain return values, error conditions, required relationships (e.g., parent must own kid), or any behavioral context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 17%, and description lists four of six parameters (birthdate, interests, school, special_needs), adding some meaning beyond the schema. However, it omits name and required kid_id, which the schema documents. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it updates a kid record and lists the fields that can be updated. The name and context distinguish it from sibling tools like parent_add_kid and parent_remove_kid.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for modifying kid details, but it does not explicitly state when to use or not use this tool versus alternatives. No prerequisites or exclusions are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
parent_update_prefsCInspectUpdate parent notification + language preferences.
| Name | Required | Description | Default |
|---|---|---|---|
| phone | No | ||
| first_name | No | ||
| sms_opt_in | No | ||
| language_preference | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, and description lacks details on authentication requirements, side effects, or permission needs 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence is concise and front-loaded, but lacks essential details for a mutation tool with 4 parameters.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema, no annotations, and description does not cover return values or required fields, leaving the tool's behavior underspecified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and description adds no meaning to parameters like phone, first_name, sms_opt_in, or language_preference beyond their names.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states verb 'Update' and resource 'parent notification + language preferences', distinguishing it from other parent tools like parent_me or parent_list_enrollments.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool vs alternatives; it is implied but not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
program_events_feedAInspectUpcoming events (practices, games, scrimmages, cancellations) for a specific program. Returns next 30 days. Use this to answer 'is there a game this Saturday?' style questions, and to power Add-to-Calendar flows.
| Name | Required | Description | Default |
|---|---|---|---|
| days_ahead | No | ||
| program_slug | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so description carries full burden. It mentions returning next 30 days but does not clarify that the optional days_ahead parameter can extend up to 90 days, creating a minor discrepancy. Missing details on authentication, rate limits, or other behavioral traits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences: first defines what the tool does, second gives use cases. No wasted words, effectively front-loaded with essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 2 parameters and no output schema, the description covers basic purpose but lacks parameter semantics and behavioral details. The 30-day default vs 90-day maximum is unclear, and there is no info on return format or pagination. Incomplete for a query tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0% with no parameter descriptions in schema. Description implies program_slug is needed ('for a specific program') but does not explain it. days_ahead is mentioned only indirectly via 'returns next 30 days', not clarifying it controls the lookahead period. Parameters are insufficiently explained.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description uses specific verb 'returns' and lists event types (practices, games, scrimmages, cancellations) for a specific program. It also clearly defines the timeframe (next 30 days) and provides concrete use cases, distinguishing it from siblings like list_upcoming_events or parent_my_upcoming_events.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use: for answering game-related questions and powering Add-to-Calendar flows. This provides clear context, though it does not mention when not to use or offer alternative tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_daycaresAInspectSearch licensed daycares in Lodi, CA. Filter by child age (in MONTHS — daycares think in months for under-5s), program kind (daycare / preschool / after_school), facility setting (in_home / center), or claimed-only (more reliable data). Returns up to 10 daycares with hours + tuition where available. For subsidy / bilingual / curriculum filters, follow up with get_daycare on a slug.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max daycares to return (1-25). Default 10. | |
| setting | No | Filter by facility setting. 'in_home' is a family child care home (smaller, residential). 'center' is a commercial facility. | |
| age_months | No | Child age in months. Returns daycares whose licensed age range includes this age. Daycares without ages_min/max populated are kept (we don't know they DON'T serve this age). | |
| claimed_only | No | If true, only return daycares whose owner has claimed the listing (more accurate data + reliable contact channel). | |
| program_kind | No | Filter by program kind. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses that the tool returns up to 10 daycares with hours and tuition where available, and explains how the age filter handles missing data. However, it does not mention authentication requirements, rate limits, or whether it is read-only. This is a minor gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loading the core purpose and filters. The second sentence provides crucial follow-up guidance without redundancy. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 5 parameters and no output schema, the description explains return details (up to 10 daycares, hours+tuition) and the age filter behavior. It lacks sorting/pagination details, but for a search tool with a default limit, it is reasonably complete. Sibling tools like 'search_programs' are clearly differentiated.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. The description adds value beyond schema by noting that child age is in months ('daycares think in months for under-5s') and that claimed-only provides 'more reliable data'. This extra context improves usability.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states 'Search licensed daycares in Lodi, CA' and lists specific filters. It distinguishes from sibling tool 'get_daycare' by mentioning when to use that instead. The verb 'search' is clear and appropriate.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool versus alternatives: it mentions that for subsidy/bilingual/curriculum filters, one should follow up with 'get_daycare' on a slug. It also explains that 'claimed-only' yields more reliable data, helping agents decide on that filter.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_programsAInspectSearch youth programs in Lodi, CA. Filter by free-text query (program name or description), category (Sports, Music, Arts, Academics, Swimming, etc.), child age (integer in years — programs that accept that age), free-only flag, or season. Returns up to 15 matching programs with full details for decision-making (cost, schedule, location, registration status).
| Name | Required | Description | Default |
|---|---|---|---|
| age | No | Child age in years. Returns programs whose age range includes this age. | |
| limit | No | Max programs to return (1-30). Default 15. | |
| query | No | Free-text search across program name + description (case-insensitive substring match). | |
| season | No | Filter by season — e.g. 'Summer', 'Fall', 'Spring', 'Winter', 'Year-Round'. | |
| category | No | Program category. Common values: Sports, Music, Arts, Academics, Swimming, Gymnastics, Dance, Enrichment, Free Programs. | |
| free_only | No | If true, only return programs with $0 cost. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description bears full responsibility. It discloses that results are limited to 15 programs by default (up to 30 via limit parameter) and include 'full details' (cost, schedule, location, registration status). It does not mention ordering, authentication, rate limits, or any side effects, but the disclosed behaviors are sufficient for basic use.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences with no filler. The first sentence states the core purpose, the second lists all filter options compactly, and the third describes the output. Information is front-loaded and each sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description compensates by stating the result includes 'full details' like cost, schedule, location, and registration status. This gives sufficient context for an agent to decide if the tool meets a query need. However, it could be more explicit about the exact fields returned. Given the moderate complexity (6 parameters) and complete schema coverage, the description is nearly complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, and the description adds context beyond the schema: it specifies that query searches across both name and description, lists example categories, clarifies age as integer years and free_only as $0 cost, and notes the default limit of 15. This adds meaningful usage context without being redundant.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool searches youth programs in Lodi, CA, and lists specific filter dimensions (query, category, age, free-only, season). The verb 'Search' and resource 'youth programs' are explicit, and it naturally distinguishes from siblings like 'search_daycares' or 'nearby_programs' by its geographic focus and program-specific purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains what filters are available, implying use when searching for youth programs by those criteria. However, it does not provide explicit guidance on when to use this tool versus alternative search or list tools among siblings (e.g., 'nearby_programs', 'list_categories'), nor does it state prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
site_directoryAInspectStructured map of LKA's public URLs and content sections. Equivalent to llms.txt — gives an AI grounding agent the full topology of the site so it knows what's worth crawling/calling.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; description lacks behavioral details like destructive/read-only, rate limits, or side effects. It implies a safe, read-only map but doesn't state it explicitly.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences, no waste, front-loaded with core purpose and analogy to llms.txt.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given zero parameters and no output schema, the description adequately conveys purpose and use case. Could enhance by clarifying output structure or confirming read-only nature.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters; description adds value by explaining the tool's output (structured map/topology) beyond the empty schema. However, it could detail the output format more concretely.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool's function: providing a structured map of public URLs and content sections, equivalent to llms.txt for AI grounding. It distinguishes itself from sibling tools by its role as a topology overview.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Description implies usage before crawling or calling other endpoints, but does not explicitly state when not to use or contrast with alternatives among many sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
upcoming_registrationsBInspectPrograms whose registration window is opening soon (within the next 60 days). Useful for parents planning ahead.
| Name | Required | Description | Default |
|---|---|---|---|
| window_days | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully disclose behavior. It states a 60-day window, but the input schema allows a window_days parameter (7-180) which is not explained. There is no mention of output format, pagination, or side effects, leaving important behavioral traits undocumented.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with no filler. It is front-loaded with the core purpose and provides a brief usage hint. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the single optional parameter and no output schema, the description covers the basic purpose but omits crucial parameter semantics. The explanation of when to use is minimal, but overall it provides a functional starting point for a simple lookup tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must explain parameters. However, it does not mention the window_days parameter at all, and it incorrectly implies a fixed 60-day window, contradicting the schema's range of 7-180. This misleads the agent about the parameter's purpose.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists programs with registration windows opening within 60 days. This is a specific verb+resource (list programs) with a clear time constraint, and it differentiates from siblings since no other tool mentions upcoming registrations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description says 'Useful for parents planning ahead,' which implies when to use it, but it does not provide explicit guidance on when not to use it or mention any alternative tools for related tasks.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Claim this connector by publishing a /.well-known/glama.json file on your server's domain with the following structure:
{
"$schema": "https://glama.ai/mcp/schemas/connector.json",
"maintainers": [{ "email": "your-email@example.com" }]
}The email address must match the email associated with your Glama account. Once published, Glama will automatically detect and verify the file within a few minutes.
Control your server's listing on Glama, including description and metadata
Access analytics and receive server usage reports
Get monitoring and health status updates for your server
Feature your server to boost visibility and reach more users
For users:
Full audit trail – every tool call is logged with inputs and outputs for compliance and debugging
Granular tool control – enable or disable individual tools per connector to limit what your AI agents can do
Centralized credential management – store and rotate API keys and OAuth tokens in one place
Change alerts – get notified when a connector changes its schema, adds or removes tools, or updates tool definitions, so nothing breaks silently
For server owners:
Proven adoption – public usage metrics on your listing show real-world traction and build trust with prospective users
Tool-level analytics – see which tools are being used most, helping you prioritize development and documentation
Direct user feedback – users can report issues and suggest improvements through the listing, giving you a channel you would not have otherwise
The connector status is unhealthy when Glama is unable to successfully connect to the server. This can happen for several reasons:
The server is experiencing an outage
The URL of the server is wrong
Credentials required to access the server are missing or invalid
If you are the owner of this MCP connector and would like to make modifications to the listing, including providing test credentials for accessing the server, please contact support@glama.ai.
No comments yet. Be the first to start the discussion!