Glue Up MCP by usefulapi

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so safety is covered. The description adds meaningful behavior beyond annotations: default mode returns the default form's items in listing order, while all=true returns every form including custom ones with their items.

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 compact and front-loads the purpose, then explains the all flag behavior efficiently. The API endpoint sentence is somewhat extra but still short and potentially useful, so the overall structure is clean without meaningful 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?

With no output schema, the description appropriately explains the returned forms and items for both all=false and all=true. Annotations cover the safety profile, and the low-complexity two-parameter schema is well covered, though pagination or error behavior is not mentioned.

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 both kind and all are already documented in the schema. The description largely mirrors the schema and adds only minor clarification about listing order and items being returned, which is not substantial parameter semantics beyond what is structured.

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

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

The description states a specific verb and resource: get the membership application forms, scoped by kind company or individual. It clearly distinguishes the company and individual variants, though it does not explicitly contrast itself with sibling tools such as list_application_form_fields or the membership getters.

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

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

It explains the all flag behavior, which implies when to use the default versus all-forms mode, but it does not state when this tool should be chosen over alternatives or when-not to use it. The guidance is therefore useful but not explicit about tool selection relative to siblings.

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

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

Annotations already declare readOnly, idempotent, non-destructive, open-world access, so the safety profile is covered. The description still adds meaningful context beyond them: it warns that the response contains personal data (a compliance/PII consideration) and pins the exact HTTP endpoint being wrapped, both of which annotations do not convey.

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

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

Two short sentences with no filler; the retrieval scope and returned fields come first, followed by the PII warning and endpoint. Every clause earns its place.

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

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

With no output schema, the description compensates by naming the returned fields, and the annotation set covers behavior. The only remaining gap is that nothing tells the agent what error or empty-result behavior looks like for a nonexistent id, but for a one-parameter read that is a minor omission.

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

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

Schema description coverage is 100% and the single parameter already documents its origin (from glueup_list_company_memberships), so the schema carries the semantics. The description only restates "by membership id" and adds nothing about format or constraints (e.g., integer, minimum 1) beyond the schema.

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

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

States a specific verb and resource ("Get one company membership by membership id") and enumerates the returned facets (members, type, address, custom properties), which separates it from glueup_list_company_memberships and glueup_get_individual_membership. The API endpoint adds unambiguous identification.

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

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

Usage is only implied: the id is described as coming from glueup_list_company_memberships, which suggests a list-then-get flow, and "Returns personal data" hints at caution. However, there is no explicit statement of when to prefer this over glueup_get_member or the list tool, nor any exclusions.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the concrete data categories returned and the backing endpoint, but says nothing about auth requirements or behavior when directory settings are unset—modest added value given annotations do the heavy lifting.

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

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

A single front-loaded sentence names the resource and the returned content, followed by the API path. No wasted clauses or repetition of the title.

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

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

With no output schema and zero parameters, the description usefully compensates by naming the three categories of settings returned. It could go further—e.g., noting the response shape or permission requirements—but it is sufficient for a simple read-only getter whose safety annotations are already explicit.

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

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

The tool takes zero parameters, so the baseline is 4 per the rubric. Schema coverage is 100% and empty by design; the description correctly implies no input 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?

States a specific verb and resource ('Get the membership directory settings') and enumerates the content returned: directory visibility, per-field visibility, and enabled search fields. The resource is clearly distinct from sibling tools like list_members or get_application_forms, though no explicit sibling comparison is made.

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 verb and resource—an agent would know to call this when it needs directory configuration. However, there is no explicit when/when-not guidance, no mention of prerequisites such as admin permissions, and no named alternatives among the many sibling getters.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered. The description adds genuinely non-obvious context: it returns personal data (a sensitivity disclosure the annotations cannot express) and names the underlying endpoint. Return shape and error behavior are still absent.

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

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

Three short sentences with zero filler; the action and scope come first, the sensitivity note and endpoint follow. Nothing is repeated or padded.

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

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

For a one-parameter single-record getter with a fully documented schema and no output schema, this is close to sufficient: the agent knows what it retrieves, what it costs in sensitivity terms, and where the id comes from. Only the shape of the returned membership record is unaddressed.

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

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

Schema coverage is 100% and the single parameter is fully documented with type, range and provenance, so the schema carries the load. The description only restates 'by membership id' and adds no format or sourcing detail beyond what the schema already says.

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

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

States a specific verb and resource ('Get one individual membership by membership id') and the singular 'one' plus 'individual' cleanly separates it from glueup_list_individual_memberships and glueup_get_company_membership. An agent can pick it out of the sibling list without opening the schema.

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

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

The phrase 'by membership id' and the schema note '(from glueup_list_individual_memberships)' imply the lookup workflow, but the description itself never states when to use this versus the list or company variants, nor any preconditions. Usage is inferable rather than stated.

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

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

Annotations already cover readOnly/idempotent/non-destructive, and the description adds genuinely new context: it flags that the result contains personal data, enumerates the payload (membership, contact data, custom properties), and gives the underlying endpoint. No auth or rate-limit notes, but the PII flag is the important behavioral signal 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 short sentences plus the endpoint, all front-loaded with the verb and resource first. Tight overall; the endpoint clause is mildly redundant but cheap.

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

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

For a one-parameter read with no output schema, the description covers what it returns at field-group level plus the PII caveat. A slightly richer return-shape note would be the only addition, but this is close to 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 description coverage is 100% and the single parameter is fully documented there, including its source field (individualMember.id). The description adds no syntax or format detail beyond the schema, so the baseline 3 applies.

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

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

Specific verb ('Get one person') plus resource ('membership directory') plus the keying parameter ('by member id'), and it names what comes back. It is clearly distinguishable from sibling glueup_list_members, which lists many.

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: retrieving a single person by id. The description never explicitly contrasts with glueup_list_members or says when not to use it, and the 'id comes from glueup_list_members' pointer lives only in the schema, not the description.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds useful context about the returned data containing keys, types, and mandatory flags, and that custom form fields are included.

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 front-loaded with the core purpose and return contents, then briefly gives the API endpoint. Every sentence is relevant and there is no filler.

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

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

For a simple read-only list tool with no output schema, the description sufficiently explains what is returned: field keys, types, mandatory flags, and inclusion of custom forms. Pagination or rate-limit behavior is not mentioned, but the essential call context is complete.

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

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

Schema description coverage is 100%, and the single enum parameter is already documented in the schema. The description's mention of "company or individual" aligns with the enum but does not add format, constraints, or behavior 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 uses a specific verb ("List") and resource ("every field of the company or individual membership application forms"), including custom forms. It distinguishes the resource as fields rather than forms, though it does not explicitly contrast with the sibling glueup_get_application_forms.

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 field definitions, including custom form fields, but does not state when to use it versus the related form or membership tools. It provides no explicit exclusions or alternative recommendations.

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

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

Annotations already declare `readOnlyHint=true`, `idempotentHint=true`, and `destructiveHint=false`, so the safety profile is covered. The description adds that only active memberships are returned and lists the default fields, which is useful context, but it does not discuss permissions, rate limits, or response shape beyond the field list.

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 tight sentences plus the API endpoint; the key purpose and field scope are front-loaded, and every sentence adds relevant information without repetition.

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

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

For a read-only list tool with no output schema, the description gives enough: it names the returned fields, explains the `basic` shortcut, and mentions filtering. It could be stronger by describing pagination or total behavior, but the schema covers pagination parameters and the annotations cover safety.

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

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

Schema description coverage is 100%, so the schema already documents `basic`, `limit`, `order`, `fields`, `offset`, `search`, `filters`, and `descending`. The description adds a few high-level examples for `basic` and filters, but most parameter semantics are already in the schema, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb and resource: it lists active company memberships and names the exact fields returned. It clearly distinguishes this from `glueup_get_company_membership` (single membership) and `glueup_list_individual_memberships` by emphasizing company memberships in the directory.

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

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

It gives clear context for use: browsing active company memberships, using `basic=true` for a reduced field set, and filtering by featured, industryCode, name prefix, and more. It does not explicitly say when not to use this tool or route to a sibling, but the listing context is clear enough.

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

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

Annotations already declare readOnly, idempotent, non-destructive and openWorld, so the safety profile is covered. The description adds two genuinely useful behavioral facts beyond that: timestamps are epoch milliseconds and the underlying call is POST /event/list[/{status}]. It says nothing about the response envelope (total count) or pagination defaults.

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

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

Three dense sentences with the resource and return fields front-loaded, followed by filter capabilities and endpoint. Every clause carries information; nothing is repeated or padded.

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

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

With 13 optional parameters and no output schema, the description gives the agent the essential framing: what is returned, the timestamp format, and which parameters are the intended primary filters. It stops short of describing the paging envelope or default sort, though the offset parameter's schema text partially covers that.

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

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

Schema description coverage is 100%, so the schema already documents all 13 parameters in detail. The description restates the filter groups (status, published, open_to_public, starts window, search) that the schema already names, adding only the epoch-millisecond note. 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?

States a specific verb and resource ('List the organization's events') plus what the records carry (dates, venue, publication flags). No sibling in the list deals with events, so this is unambiguously distinguishable from the membership/invoice/directory 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?

It enumerates the available narrowing strategies (status, published/open-to-public flags, start-date window, title word), which implies how the tool is meant to be used. However, it never says when to prefer one filter over another, when not to use this tool, or what to do with the sibling listing tools.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior. The description adds valuable context beyond that: it notes 'Returns personal data' (privacy implication) and gives the raw API endpoint (POST for a read operation), which is useful for understanding behavior. Pagination behavior is left to the schema.

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

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

The description is front-loaded with the tool's purpose and returned fields, then adds a privacy note and API endpoint. Three short sentences with little waste; the API line is somewhat extraneous for an AI agent but provides developer context.

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

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

For a 7-parameter list tool with no output schema, the description adequately explains what is returned ('each with its person, membership type, start date and contact data') and flags personal data. Pagination is covered by the schema. Complete enough for correct invocation.

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

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

Schema description coverage is 100%, so all seven parameters are fully documented in the schema. The description adds no parameter-level information, which is the expected baseline (3) when the schema already does the heavy lifting.

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

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

States a specific verb (List) and resource (active individual people memberships), and distinguishes from company memberships by qualifying 'individual (people)'. Also lists the returned fields. Clear, but does not explicitly name sibling tools to route against.

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

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

The description explains what the tool does but provides no guidance on when to use it versus alternatives like get_individual_membership or list_members. Usage is only implied by the tool name and context.

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

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

Annotations already declare readOnly, idempotent, non-destructive and openWorld, so the safety profile is covered. The description adds only the underlying GET path; it says nothing about ordering, whether the list is exhaustive, or pagination behavior for large directories.

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

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

Two compact clauses with no filler: purpose first, then filter context, then the endpoint. Nothing is repeated or wasted.

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 should say what a 'code' looks like (a bare string vs. an object with id/label) and whether results are paginated, since that determines how the agent feeds the values into an industryCode filter. It is otherwise adequate for a one-parameter lookup.

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 has an enum and 100% schema description coverage, so the schema already carries the semantics. The description restates the People/Company scope but adds no detail on how the choice affects the returned code set beyond what the enum conveys.

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

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

States a specific verb and resource ('List the industry codes') scoped to People or Company memberships, and clarifies the role as the source of values for an industryCode filter, which separates it from the membership-listing siblings. It does not name a specific sibling alternative, so it stops short of a 5.

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

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

The parenthetical 'the values for an industryCode filter' gives a concrete usage context: call this before filtering memberships by industry. There are no explicit exclusions or named alternatives, but the intended call site is unambiguous for such a narrow lookup tool.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds useful behavioral context beyond that: dates are epoch milliseconds, purchaser names and emails are returned, and it names the underlying API path. It does not discuss rate limits or pagination behavior beyond what the schema states.

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

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

Two compact sentences plus a short API line; the returned-field list and filtering capability are front-loaded with no filler. Slightly dense in its field enumeration, but every element carries 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?

There is no output schema, and the description compensates by describing the returned fields and that purchaser names and emails come back. Combined with complete parameter documentation and read-only annotations, an agent has what it needs; only minor gaps like sorting/pagination caveats remain, and those live in the 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 description coverage is 100%, so limit/offset/order/fields/filters are already fully documented, which sets the baseline at 3. The description reinforces the status filter with an example ('Overdue') and clarifies date values are epoch milliseconds, but adds little else the schema doesn't already say.

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

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

States a specific verb and resource ('List the organization's finance invoices') and enumerates the data it covers (number, currency, totals, purchaser, voided flag, dates), plus the backing endpoint POST /finance/invoice/list. It does not explicitly differentiate from siblings, but no other invoice tool exists in the sibling set, so an agent can place it unambiguously.

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?

Says it can be filtered 'by status (e.g. Overdue) or any property', which implies how to narrow results, but gives no when-to-use/when-not guidance and no exclusions. With no competing invoice-listing tool the implied usage is adequate but thin.

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

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

Annotations already establish that this is a safe read-only, idempotent, non-destructive, open-world operation. The description adds meaningful behavioral context beyond annotations by warning that the tool 'Returns personal data' and explaining that basic=true limits results to basic public fields.

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 front-loaded with the core purpose and return fields, then efficiently covers the personal-data warning, basic mode, search/filter capabilities, and API path. Every sentence contributes useful information without repetition.

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 8 optional parameters, high schema coverage, and no output schema, the description does well by listing returned fields, clarifying basic mode, and summarizing search/filter behavior. It omits pagination and sorting details, but those are covered by the parameter schema, so the description is nearly complete for correct invocation.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds useful semantic detail: basic=true returns only public fields, search targets name/email/company, and filters can target featured, familyName, or custom properties like properties.<custom-field>. It does not explain pagination or ordering behavior, but the schema already documents those parameters well.

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 and resource: 'List the active people in the membership directory,' and enumerates returned fields (name, company, position, membership type, start date, contact data, custom properties). It clearly distinguishes the plural listing operation from the sibling single-record retrieval tool glueup_get_member.

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 clear usage context: search by name, email, or company; filter by any property including custom fields; and use basic=true for public fields only. It does not explicitly name when to choose this over sibling tools such as glueup_get_member, but the listing scope makes the distinction clear.

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

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

Annotations already cover readOnly/idempotent/non-destructive, so the bar is lower, and the description adds real value: the word "published" discloses that drafts/unpublished tiers are excluded, and the POST endpoint clarifies that a POST verb here is still a read operation. It does not mention pagination defaults or result volume, which the schema partially covers.

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

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

Two compact sentences, with the substantive content (what is listed and which fields come back) front-loaded before the endpoint reference. The API endpoint line is marginally extraneous for tool selection but cheap and occasionally useful for debugging.

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 does the necessary work of naming the key returned attributes, and all 8 input parameters are fully documented in the schema. It stops short of describing pagination totals or the shape of price-version objects, but nothing critical to a correct call is missing.

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

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

Schema description coverage is 100% across all 8 parameters, including the filters operator enum and field examples, so the schema carries parameter meaning entirely. The description adds nothing about limit/offset/fields/search/filters, which is the expected baseline-3 outcome when the schema is this complete.

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

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

States a specific verb and resource ("List the published membership types (tiers)") and even enumerates the returned attributes (price versions, durations, member limits, approval required). It is clearly distinct from siblings like list_company_memberships or list_individual_memberships, though it never explicitly names an alternative to route away from.

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

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

Usage is only implied by the resource name — an agent can infer this is the catalog lookup for tiers, but there is no statement of when to prefer it over get_company_membership/get_individual_membership or how to page/filter through results. No exclusions or prerequisites are given.

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