copper

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

The only behavioral content is the REST endpoint (POST /companies), which is a minor implementation detail. The description says nothing about required permissions, duplicate handling, what happens on conflict, or what the call returns. The destructiveHint=true annotation is present but the description neither explains nor contradicts it, so the description carries almost no additional behavioral weight.

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 fragments with zero padding and the primary action front-loaded. It is efficient, though the endpoint fragment is arguably filler for most agents.

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 six-parameter mutation tool with no output schema, the description should at least indicate what is returned (e.g., the created company and its id) and any prerequisite such as authentication or duplicate-name behavior. None of that is present, leaving meaningful gaps.

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

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

Schema description coverage is 100%, so all six parameters (name, tags, details, assignee_id, email_domain, phone_numbers) are already documented in the schema. The description adds no format, constraint, or default information beyond that, so the baseline of 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?

States a specific verb and resource ("Create a new company") that clearly distinguishes it from copper_create_person, copper_create_lead, and copper_create_opportunity. It does not, however, explicitly contrast itself with sibling creation tools or search tools, so it is clear but not maximally differentiated.

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 - e.g., whether to call copper_search_companies first to avoid duplicates, or when to prefer copper_create_lead/copper_create_opportunity. The agent must infer usage entirely from the name.

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

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

Annotations declare destructiveHint=true (mutation) and there are no other behavioral notes. The description says 'Create' which is consistent with a create operation, but it doesn't disclose what happens on duplicate leads, required permissions, or side effects. With annotations already carrying the mutation signal, the description adds almost nothing beyond API mapping.

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 resource, 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 10-param create tool with nested objects and no output schema, the description is minimally adequate. It doesn't explain return values (no output schema), nor does it highlight required vs. optional beyond what the schema already shows. It is sufficient to call the tool but thin on context.

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

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

Schema description coverage is 100%, so every parameter is documented in the schema. The description adds no parameter-level meaning beyond what is already in structured data. 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 states a clear verb and resource: 'Create a new lead.' It also gives the underlying API endpoint, which helps an agent map to Copper's REST semantics. It doesn't explicitly distinguish from sibling creation tools, but the resource 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?

The purpose implies use to create a lead, and the REST endpoint ties it to the Copper API. It does not specify when to choose this vs. sibling tools like copper_create_person or copper_create_opportunity, nor any prerequisites or constraints.

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 supply only destructiveHint=true, so the description must carry most of the behavioral burden. It adds that Copper itself enforces name and primary_contact_id, but says nothing about permissions, side effects, duplicate handling, or what happens to unset 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?

Two tight sentences with the operation front-loaded, followed by the API endpoint; no filler or 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 10-parameter mutation tool with no output schema and minimal annotations, the description omits what is returned (e.g., the new opportunity id) and any post-creation notes, leaving an agent unsure how to chain follow-up calls.

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 every parameter is described in the schema, so the description's restatement of the two required fields adds little. Baseline 3 applies when the schema does the heavy lifting.

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

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

States a specific verb and resource ('Create a new opportunity (deal)') and reinforces it with the underlying REST call. It is clearly distinguishable from the other copper_create_* siblings, though it does not explicitly name the alternative tools (lead vs. opportunity).

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 create an opportunity versus a lead or company, nor any prerequisite or ordering advice (e.g., whether the contact/company must already exist). The required-field note is a constraint, not usage guidance.

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

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

Annotations only provide destructiveHint=true, which gives no real safety profile for a creation tool, so the description carries most of the burden. It adds nothing about duplicate handling, required permissions, side effects, or whether the created record is returned.

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 front-loaded sentences with no filler; the REST endpoint annotation is marginally useful for traceability. Nothing is padded, though the endpoint string could be considered non-essential.

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

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

For a 9-parameter mutation tool with no output schema, the description should at least indicate what the call returns (new person id?) and any duplicate/permission behavior. It leaves both unstated, so an agent cannot predict the outcome of the call.

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

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

Schema coverage is 100% and every one of the 9 parameters is documented in the schema, so the description need not repeat them. It adds no extra meaning (e.g. company_id vs company_name precedence is left entirely to the schema), which is the baseline-3 case.

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

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

States a specific verb and resource ('Create a new person (contact)') and even names the underlying REST operation. It is clearly distinguishable from siblings like copper_create_company or copper_create_lead by resource, though it never explicitly contrasts with them.

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

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

No guidance on when to use this versus alternatives such as copper_search_people (dedupe check) or copper_create_lead, and no prerequisites or conditions are stated. The agent must infer all usage context from the tool name alone.

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

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

Annotations supply only destructiveHint=true, leaving the description to carry the rest, and it adds nothing beyond 'Create a new task' plus the REST verb. It discloses no auth/permission requirements, no side effects, no confirmation of what is created or what identifier comes back. The REST endpoint line is a mapping aid, not 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 short sentences with the action front-loaded and zero filler. The 'Copper REST: POST /tasks' line is the one marginally expendable element, but it is cheap and helps API-aware agents.

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 nine-parameter creation tool with no output schema and only a destructiveHint annotation, the description is too thin: it omits the return value (e.g., the new task id), the required pairing of related_resource fields, and any defaults or constraints agents need before calling.

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 nine parameters (name, tags, details, due_date, priority, assignee_id, reminder_date, related_resource_id/type) are already documented in the schema. The description adds no syntax, format, or interaction detail beyond that, 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?

States a specific verb ('Create') and resource ('task'), and the resource name alone distinguishes it from the sibling creators (company, lead, opportunity, person). It stops short of any explicit sibling differentiation or scope statement, but the purpose is unmistakable.

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

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

No when-to-use guidance, no prerequisites, no alternatives named. It does not say when to create a task versus logging an activity, nor that attaching a task to a record requires the related_resource_type/id pair to be supplied together (only the schema hints at that).

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, so the safety profile is covered. The description usefully clarifies that the account is implicit to the authenticated session (no identifier needed) and cites the underlying REST call, but says nothing about what fields come back or any scoping/permission caveats.

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 terse sentences, the salient scope ('authenticated Copper account') front-loaded, with the REST mapping as a compact trailing note. 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 no-argument read tool with annotations covering safety, the definition is nearly sufficient. The main omission is return content, which matters slightly more here since no output schema exists, but the expected payload (account details) is at least implied.

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?

Zero parameters, so the baseline is 4. The description reinforces this by stating the account is the authenticated one, telling the agent no ID or filter argument is expected — a meaningful clarification 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?

Specific verb+resource: 'Get details of the authenticated Copper account', which cleanly separates it from sibling getters like copper_get_company/get_lead that target CRM entities. The 'authenticated account' phrasing makes the scope unambiguous, though it doesn't explicitly contrast with the entity-level 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?

Usage is implied by the resource — fetch the current account's details — but there is no explicit when-to-use statement or exclusion. In practice the tool is self-selecting since it is the only account-scoped tool, so the gap is small.

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, so the safety profile is covered without description help. The added 'Copper REST: GET /companies/{id}' line gives useful provenance for an agent reasoning about errors or auth, but nothing about 404/not-found behavior or the returned record shape.

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

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

Two short sentences, zero filler, with the core action front-loaded. Nothing could be removed without losing content.

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

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

For a one-parameter read-only getter with full schema coverage and a readOnly annotation, the description covers the essentials. The absence of an output schema means the agent gets no signal about the returned company shape, which is the only notable remaining 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?

Schema description coverage is 100% and there is a single required 'id' parameter already documented in the schema, so the baseline of 3 applies. The description adds no format hints such as whether the id is the numeric Copper record id.

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

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

States a specific verb ('Get') and resource ('a single company by id'), which cleanly separates it from the sibling get_lead/get_person/get_opportunity tools. It does not, however, distinguish itself from copper_search_companies, which an agent could easily confuse with a by-id fetch.

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

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

There is no when-to-use guidance and no mention of the obvious alternative, copper_search_companies. The description never states that this requires a known numeric id, which is the key selection condition between the two.

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?

readOnlyHint=true already tells the agent this is a safe read with no side effects, so the description carries a lower burden. It adds the underlying REST mapping (GET /leads/{id}), which is mildly useful for orientation but reveals nothing about error behavior 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 short sentences, front-loaded with the action and resource, with zero filler. 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?

For a one-parameter read tool with annotations covering the safety profile and no output schema needing explanation, the description is sufficient to invoke correctly. Only minor gaps remain around 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?

Schema description coverage is 100% and the single 'id' parameter is documented in the schema, so the description adds no meaning beyond it. 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?

States a specific verb ('Get') and resource ('lead') with a scoping qualifier ('by id'), which cleanly separates it from copper_search_leads and copper_list_* siblings. It doesn't explicitly name which sibling to use instead, so it falls just 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 'by id' phrasing implies the single-record lookup case versus search, but there is no explicit when-to-use guidance, no stated preconditions (e.g. that the id must exist or come from a search result), and no named alternative.

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, so the safety profile is covered. The description adds the underlying REST mapping (GET /opportunities/{id}), which is useful orientation, but says nothing about behavior on a missing id, permissions, or response shape.

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

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

Two short sentences, verb-and-resource first, with the REST endpoint appended as a compact reference. Nothing is padded or redundant.

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 single-entity read with no output schema, the description plus the readOnlyHint annotation give the agent enough to call it correctly. Return value detail is not required, though a note on not-found handling would round it out.

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 and schema description coverage is 100%, so the schema fully documents 'id'. The description's 'by id' only restates what the schema already says, earning the baseline rather than above it.

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 a single opportunity') plus the disambiguating synonym 'deal' and the lookup key ('by id'). It does not explicitly name the sibling it differs from (copper_search_opportunities), so it falls short of the top band.

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 'by id' phrasing signals single-record retrieval versus the sibling search tools, but the description names no alternative, no when-not-to-use condition, and no prerequisites. Minimum-viable context rather than real guidance.

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

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

Annotations already declare readOnlyHint=true, so the agent knows this is a safe read operation. The description adds only the REST endpoint (GET /people/{id}), which confirms rather than extends the annotation, and it says nothing about authentication, error behavior, rate limits, or whether missing records return null or throw.

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 core action and then the API endpoint mapping. There is no filler or repetition, and both sentences earn their place.

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

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

For a simple one-parameter read with complete schema coverage and readOnly annotations, the description is minimally adequate. However, with no output schema present, it does not describe what the returned person object contains or what a not-found response looks like, leaving a small but real 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?

Schema description coverage is 100%, and the single parameter already has a description ('The person id.'). The description's 'by id' and '/people/{id}' add no syntax, format, or constraint detail beyond what the schema provides, so the 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 ('Get'), resource ('a single person (contact)'), and lookup key ('by id'), plus the exact REST endpoint. An agent can distinguish this from sibling getters like copper_get_company or copper_get_lead without opening any 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 'by id' phrasing implies the tool is for direct lookup when a person id is already known, but it gives no explicit when-to-use guidance, no exclusions, and does not name alternatives such as copper_search_people for finding a person by other attributes.

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, so the safe-read profile is covered by structured data. The description adds only the underlying REST route (GET /tasks/{id}); it says nothing about not-found/error behavior, authentication, or what fields come back.

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, zero filler, with the core action front-loaded. Nothing in the text is redundant enough to warrant trimming.

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 tool with readOnlyHint provided, the description is sufficient to invoke it correctly. Since no output schema exists, a brief note on the returned task shape would have closed the remaining 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?

There is a single required parameter with 100% schema description coverage, so the schema already documents it. 'By id' adds no syntax, format, or constraint detail beyond what the schema's 'The task id' already provides, matching the baseline for a fully-covered 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 (Get) and resource (a single task) and scopes it to lookup by id, which implicitly separates it from copper_search_tasks and copper_create_task. It stops short of naming an alternative sibling, so it is clear but not fully differentiated.

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 id' implies the caller must already hold a task id, which is a usable cue, but the description never states when to prefer this over copper_search_tasks or what to do when only a name is known. Usage is implied 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?

readOnlyHint=true already declares this a safe read, so the safety profile is covered. The description adds the activity-type taxonomy and the underlying POST /activities/search behavior, but says nothing about pagination defaults, result ordering, or rate limits 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 tightly written sentences: purpose and subtypes come first, the endpoint detail second. No filler and nothing redundant, so 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?

For a read-only list tool with full schema coverage and no output schema, the description supplies enough to call it correctly: what it returns conceptually and the record-scoping model. It stops short of explaining pagination/return shape, but with no output schema that 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?

Schema description coverage is 100%, so all six parameters (including the parent_id/parent_type pairing and the timestamp bounds) are fully documented in the schema. The description's phrase 'attached to a record' loosely gestures at parent_id/parent_type but adds no syntax or semantics beyond the schema, making the baseline 3 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 (List) and resource (activities), enumerates the subtypes covered (notes, calls, meetings, system events), and constrains scope to activities 'attached to a record'. Combined with the REST endpoint reference, an agent can distinguish this from copper_log_activity and copper_list_activity_types 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 description gives no when-to-use, when-not-to-use, or alternative tool guidance. It does not say, for example, to use copper_log_activity to create an activity or when parent_id/parent_type filtering is required versus leaving them unset, so the agent must infer usage entirely.

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

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

readOnlyHint=true already tells the agent this is a safe, non-mutating read, so the description only needs to add context. It contributes the returned scope ('user + system' types) and the upstream REST endpoint, which are modest but real additions; it says nothing about volume, ordering, or caching.

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 filler, and the functional statement comes first with the dependency and REST mapping trailing. Every clause 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?

For a no-parameter, read-only enumeration tool with a trivially simple schema, the description covers purpose, content scope, and the workflow dependency. The only gap is the absence of an output schema paired with a description that does not sketch the returned fields (e.g., type id/name).

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 of 4 applies. Schema coverage is 100% and there is nothing parameter-related the description could 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?

States a specific verb and resource ('List the account's activity types') and narrows scope with '(user + system)'. It is easily distinguished from copper_list_activities (activity instances) and copper_log_activity (writes), which are the closest 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?

Explicitly frames the tool as a prerequisite: 'needed to log an activity', which routes the agent toward copper_log_activity before writing. It offers no when-not-to-use guidance or comparison to copper_list_activities, so it stops short of full routing coverage.

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?

The readOnlyHint annotation already declares this a safe read, so the bar is lower. The description adds the returned structure (pipelines with their stages), which is useful, but says nothing about pagination, result size limits, or whether pipelines are workspace-scoped.

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 tight sentences, front-loaded with what is returned and why it matters, then the underlying REST route. 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?

With no output schema, the description carries responsibility for describing the return value, and it does so briefly (pipelines and stages with ids). Missing only pagination/ordering details, which are unlikely to matter for a small pipeline list.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The empty schema matches the description's claim of a plain list call.

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 (sales pipelines and their stages), and goes further by naming the payload's purpose: the ids needed to place opportunities. None of the sibling list_* tools (activities, activity_types, users) overlaps with this 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?

The clause 'ids needed to place opportunities' tells the agent the precondition that selects this tool before creating an opportunity, which is clear context. It does not, however, name an explicit alternative or state when not to call it.

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

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

The readOnlyHint annotation already establishes the safety profile, so the bar is lower. The description adds that retrieval is backed by POST /users/search, which is genuinely non-obvious for a "list" operation, but says nothing about result caps, pagination totals, or permissions.

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 carrying purpose, returned fields, and use case, plus one short line of endpoint metadata. Nothing is padded, though the REST endpoint note is marginally useful at best.

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

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

This is a simple paginated read with no output schema, so the description's enumeration of returned fields usefully compensates. Pagination behavior is fully covered by the schema, leaving only permissions and total-count semantics unstated.

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

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

Schema coverage is 100% with both page_size and page_number fully documented including defaults and max values, so the baseline of 3 applies. The description mentions only returned fields, adding nothing beyond the schema on 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?

States a specific verb and resource ("List users in the Copper account"), names the returned fields (id, name, email), and gives the tool's role: resolving assignee ids. No other sibling tool operates on users, so there is no ambiguity to resolve.

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?

"Useful for resolving assignee ids" gives a concrete use context, which is more than most list tools offer. It stops short of stating when not to use it or naming an alternative source of user data, but no sibling overlaps this function.

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 only declare destructiveHint=true, and the description adds no behavioral context beyond that – it never explains the write semantics, permission/auth needs, default behavior (schema covers the date default, not the description), or what the destructive flag implies. 'Copper REST: POST /activities' merely restates that it writes, adding no insight for the 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?

Three short sentences, front-loaded with the action, then the prerequisite, then the underlying endpoint. Every sentence carries information with 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 5-param write tool with no output schema and sparse annotations, the description covers the what, the required id source, and the REST action. It would be stronger with a note on return/linkage behavior, but nothing essential to correct invocation 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%, so all five parameters are already documented in the schema, establishing the baseline of 3. The description adds only the source pointer for activity_type_id, which is marginal value on top of structured data.

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

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

States a specific verb+resource ('Log a user activity') and clarifies it is attached 'on a record', with concrete examples (a note or call). It does not differentiate from siblings like copper_create_task, which also create records, 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?

Gives a clear prerequisite/pointer: 'Get the activity_type_id from copper_list_activity_types', routing the agent to the right companion tool. No when-not guidance or exclusion conditions are offered, so it is not a full 5.

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, so the safety profile is covered. The description adds genuine context beyond annotations: the fact that all filters are optional and that it returns a page (pagination), plus the REST endpoint. It does not describe pagination limits or empty-result behavior, but is adequate given the low annotation bar.

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, front-loaded sentences with zero filler; the tool's purpose leads. The endpoint line is marginally useful but earns its place as an implementation 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?

With 10 optional params, a read-only annotation and no output schema, the description covers the essentials but is thin. It could say what fields are returned or how paging behaves, though the schema already covers filters and pagination params.

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 fully documents all 10 parameters (city, name, tags, sort_by, page_size, etc.). The description only adds the meta-statement that all filters are optional, which is baseline-consistent with 0 required params. No syntax or semantic 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?

States a specific verb ('search/list') and resource ('companies'), and the description is clearly distinguishable from the sibling search_people/search_leads/search_opportunities tools because the resource differs. It does not explicitly name alternatives, but the resource 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?

'Search/list companies. All filters optional' implies the tool is used for broad retrieval with optional narrowing, but there is no explicit statement of when to use this versus copper_get_company (single lookup) or the create_* siblings. Usage is inferred 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 declare readOnlyHint=true, so the safety profile is covered. The description adds that results are paginated ('returns a page of leads') and names the underlying REST call, which is useful context, but says nothing about maximum page size, sort defaults, or result shape beyond what the schema already carries.

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 clauses, front-loaded with the verb and resource, with no filler. The REST endpoint note is arguably redundant but compact and mildly useful.

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 12-parameter, all-optional, read-only search tool with full schema coverage and no output schema, the description covers the essentials: filters optional, paginated results. It lacks detail on pagination limits and return fields, but the schema and readOnlyHint annotation carry most of the burden.

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 every one of the 12 parameters (city, tags, assignee_ids, sort_by, page_size, etc.) is already documented with defaults and bounds in the schema. The description adds only that all filters are optional, which is a marginal contribution.

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 the specific verb (search/list) and resource (leads), which cleanly distinguishes it from siblings like copper_search_companies, copper_search_people, and copper_search_opportunities. The REST endpoint hint reinforces the operation. It stops short of 5 only because it doesn't contrast itself with the read-one sibling copper_get_lead.

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?

'All filters optional' implies the tool is safe to call with an empty body, but there is no explicit when-to-use guidance versus copper_get_lead or copper_list_activities, and no exclusions. Usage is inferable from the name and resource 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?

readOnlyHint=true already tells the agent this is a safe read, so the bar is lower. The description adds two useful facts beyond the annotation: it is backed by POST /opportunities/search and it returns a paginated result set. It says nothing about the shape of returned records, total counts, 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 short sentences, front-loaded with the core purpose and free of padding. The clause "returns a page of opportunities" overlaps slightly with "All filters optional" as a general statement, but nothing is wasteful.

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

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

For an 11-parameter search tool with no output schema, the description covers purpose and pagination but does not convey what a returned opportunity contains or how to page through all results. It is minimally sufficient given the readOnly annotation, but leaves the agent to open the schema for anything operational.

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 each of the 11 parameters carries its own description (including enum meanings for status_ids), so the schema does the heavy lifting. The description adds no filter syntax or format detail beyond the schema; 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 (search/list opportunities, clarified as deals), which is distinguishable from the create/get siblings by name and intent. It stops short of explicitly contrasting with e.g. copper_get_opportunity or copper_search_companies, but the purpose is unambiguous.

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

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

"All filters optional" implies a broad listing/query use case and the pagination note implies result-set traversal, but there is no explicit when-to-use guidance or mention of the alternative tools (get_ for single records, create_ for writes). 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?

readOnlyHint=true already declares the read-only safety profile, and the description adds value by disclosing pagination ("returns a page of people") and that all filters are optional. It does not mention default page size, total counts, or the POST-for-search quirk's implications, so it adds some but not rich behavioral context.

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

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

Three short, front-loaded clauses with no padding; the purpose and pagination hint come first. The trailing REST endpoint note (POST /people/search) is slightly extraneous for an agent but not harmful.

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

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

For a 13-param, no-required-args search with full schema coverage and no output schema, the description covers the essentials: what it returns (a page), that filters are optional, and the read-only nature. It omits pagination mechanics beyond "a page", but nothing critical for correct invocation 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%, so all 13 filters, defaults, and the sort enum are already documented in the schema. The description only reaffirms that filters are optional, adding no syntax or interpretation beyond the schema — the correct baseline of 3.

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

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

States a specific verb+resource ("Search/list people (contacts)") and clarifies the domain object so it is distinguishable from sibling searches like copper_search_companies or copper_search_leads. It does not explicitly name an alternative, but the resource noun 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?

"All filters optional" gives useful context that an empty call lists people, which is a form of usage guidance. However, there is no when-to-use/when-not guidance, no mention of when to prefer copper_get_person for a known id, and no routing to sibling 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?

The readOnlyHint annotation already establishes this as a safe read. The description adds useful context beyond that: 'All filters optional' (no filter is required to get results) and 'returns a page of tasks' (paginated output), plus the underlying REST call POST /tasks/search. It stops short of describing result shape or paging limits, 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?

Three terse fragments with the core purpose front-loaded and zero filler. Every clause carries information: what it does, that filters are optional, and what comes back.

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?

Parameters are fully covered by the schema and no output schema exists, so the description should ideally hint at what a returned task contains or how paging behaves; 'returns a page of tasks' only partially fills that gap. Adequate but minimal for a 7-parameter search 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 100%, so all seven parameters (name, status, sort_by, sort_direction, page_size, page_number, assignee_ids) are already documented with defaults, ranges and enums. The description adds nothing parameter-specific, so the baseline of 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+resource ('Search/list tasks') that clearly distinguishes it from siblings like copper_search_people or copper_get_task by the tasks resource. It doesn't explicitly contrast with alternatives, but the resource scope plus the noted optional filters make the intent 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?

'All filters optional' implies broad, filter-driven listing, but there is no explicit when-to-use guidance and no mention of when to prefer copper_get_task (single task) or a create/update path instead. Usage is inferred 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 declare destructiveHint=true, and the description adds a genuinely useful behavioral fact: only provided fields are changed (patch-like semantics). However, it omits the important nuance visible in the schema that array fields like tags, emails and phone_numbers are wholesale replaced rather than merged, and it gives no auth/permission or error context for a destructive write.

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, zero filler, with the core behavior front-loaded. The trailing 'Copper REST: PUT /people/{id}' line is developer-oriented trivia that adds little to tool selection, so not quite a 5.

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

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

For a 9-parameter destructive update with no output schema and no annotations beyond destructiveHint, the description covers the essentials but leaves gaps: no mention of the array-replacement behavior, no confirmation of update-vs-replace at the top level beyond one clause, and no error/failure context.

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

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

Schema description coverage is 100% across all 9 parameters, so the schema already carries the field-level meaning. The description only adds the top-level partial-update rule and does not extend per-parameter semantics, 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?

Clear specific verb+resource ('Update fields on an existing person'), and the partial-update clause pins down the semantics of the operation. It implicitly distinguishes itself from copper_create_person, but never names the sibling or explicitly contrasts create vs update boundaries.

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 word 'existing' implies the entity must already exist, which is the only usage cue. There is no guidance on prerequisites (e.g. resolving the id via copper_get_person) or on when to prefer a more specific sibling tool.

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