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

With no annotations, the description carries the behavioral burden and does disclose an important safety behavior: destructive actions are blocked unless MC_NEXT_ALLOW_DESTRUCTIVE=true, plus the file-upload formData expectation. However, it does not address authorization, side effects, idempotency, or response/error behavior, leaving meaningful uncertainty for a generic action invoker.

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: the first defines the tool's scope with examples, and the second packs two critical caveats (destructive actions and file uploads). There is no filler, and the most important usage guardrail appears early.

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 generic endpoint-driven action tool with no output schema and no annotations, it provides adequate starting context: operation category, destructive-action guardrail, and file-upload format. It does not mention response/error behavior or per-endpoint discovery beyond what the schema already says about mcnext_list_endpoints, so completeness is moderate.

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. The description's formData hint largely restates the schema's note about file fields taking an absolute path, adding little beyond what the input schema already provides.

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 opens with a specific verb ('Invoke') and resource ('non-CRUD operation (kind "action")'), reinforced by a concrete list of action verbs. This clearly distinguishes the tool from the CRUD-oriented siblings like mcnext_create, mcnext_update, and mcnext_delete.

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

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

The description implies usage by framing the tool as the non-CRUD counterpart to sibling CRUD tools and gives representative action verbs, but it never explicitly names alternative tools or states when not to use it. The destructive-action guardrail adds a usage constraint but not tool-selection guidance.

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

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

No annotations are provided, so the description carries the full burden. It discloses the HTTP method (POST) and that it creates a record, but says nothing about side effects, authorization requirements, error behavior, or return format. For a mutation tool, this is a significant gap.

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

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

Two concise sentences with no waste. The primary action is front-loaded, and the critical prerequisite (using describe_endpoint) is stated clearly. Efficient and well-structured.

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

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

For a create operation with no output schema, the description is adequate for basic usage but incomplete. It lacks information about what the response will contain, whether the operation is idempotent, or any authentication prerequisites. The pointer to describe_endpoint partially compensates for body structure, but the overall behavioral context is thin.

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%, so all parameters are documented in the schema. The description adds value by pointing to mcnext_describe_endpoint for the body schema and sample, which helps the agent construct a valid payload. It also reinforces the role of the 'body' parameter.

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

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

The description clearly states the verb 'Create' and resource 'a record', and specifies it is a POST of kind 'create'. This distinguishes it from read/update/delete tools, though it does not explicitly name sibling tools. The purpose is unambiguous and actionable.

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 instructs the agent to use mcnext_describe_endpoint to obtain the expected body schema and sample, which is essential for correct invocation. However, it does not explicitly state when to prefer this over mcnext_update or other mutation tools, leaving that to 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?

With no annotations, the description carries the full behavioral burden and does disclose the most critical traits: the operation is destructive and gated by an environment variable. It stops short of stating irreversibility or success/error behavior, but the destructive guardrail is substantive.

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

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

The definition is a single compact sentence that front-loads the action and follows with necessary constraints. The parenthetical 'kind "delete"' is slightly redundant with 'Delete', but the overall structure has no fluff.

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

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

The description covers the safety gate and path requirement, and the schema documents all parameters. However, with no output schema it does not describe what a successful delete returns or whether deletion is permanent/irreversible, leaving an agent without a complete model of the call's result.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by warning that the path parameter is required even though pathParams is not marked required in the schema, and it does not repeat the schema's property descriptions.

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 ('Delete a record') and reinforces it with the HTTP method DELETE. The name and title additionally scope it to Marketing Cloud Next / Data 360, clearly distinguishing it from the SF delete siblings and from mcnext_create/update/action.

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

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

It provides actionable invocation context: the path parameter is required, and the tool is blocked unless MC_NEXT_ALLOW_DESTRUCTIVE=true. This tells the agent the preconditions and an explicit condition under which not to attempt the call, though it does not name alternative tools.

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

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

No annotations are provided, so the description carries the full burden. It is transparent that this is a read-only descriptor tool that returns a full endpoint contract, and 'before invoking' implies it does not execute the endpoint. It omits potential auth/error details, but they are less critical for a describe operation.

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

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

Two sentences, front-loaded with the tool's core purpose and output contents, followed by an explicit usage instruction. Every sentence earns its place with no redundancy.

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

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

For a single-parameter metadata tool with no output schema and no annotations, the description is complete: it lists return contents, states when to call it, and the schema fully documents the one parameter. An agent has enough to select and invoke it correctly.

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

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

Schema description coverage is 100%: endpointId is well documented with examples and discovery instructions. The main description adds no additional parameter semantics, so the baseline score of 3 is appropriate.

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

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

The description names a specific verb ('Get'), a specific resource ('full contract for one endpoint'), and enumerates exactly what is returned: method, base URL family, path, params, body schema, sample body. It clearly differentiates this metadata tool from sibling endpoint-execution tools like mcnext_query or mcnext_create.

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 explicitly says to call this tool before invoking an endpoint, which is a clear trigger condition. The endpointId parameter description also tells the agent to use mcnext_list_endpoints to discover ids, giving complementary tool guidance.

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

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

No annotations are provided, so the description must disclose behavior. 'Browse' implies a read-only, non-destructive operation, but the description does not explicitly state it, nor does it mention pagination, response format, rate limits, or any side effects. It does add the counts (445, 27, 35, 383, 44) which are useful context. Given the tool's simplicity, this is adequate but not rich. A 3 reflects the moderate disclosure.

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

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

Two sentences with zero waste. The first sentence packs the scope (445 endpoints, families, groups) and the second sentence gives the usage directive and filter options. Front-loaded and to the point.

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

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

The description provides the core purpose, scope, and usage direction. It lacks an explicit statement of the return format (e.g., list of endpoint metadata with id, name, path), but that is inferable from the tool type and the mention of 'discover the endpoint id.' For a listing/discovery tool with no output schema, this is sufficient. A 5 would be given if it detailed pagination or response structure, but the tool is simple enough.

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 86% (6 of 7 parameters have descriptions), so the schema already documents most parameters. The description adds a summary of filters: 'Filter by family, group, kind, method, or a free-text search.' This helps agents understand the grouping but does not add syntax or format details beyond the schema. The missing parameter (method) is covered by its enum. 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 specific verb ('Browse') and resource ('445 endpoints across 3 API families... 44 resource groups'), and clarifies its role as a discovery tool: 'Use this first to discover the endpoint id you need.' It clearly distinguishes from siblings like mcnext_query or mcnext_read, which execute operations on specific endpoints. No ambiguity.

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

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

The description explicitly states when to use it: 'Use this first to discover the endpoint id you need.' This gives clear context and implies it precedes other mcnext_* tools. It does not explicitly name alternatives or conditions to avoid, but the purpose is unambiguous given the sibling tool names. A 4 is appropriate; a 5 would require explicit 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?

With no annotations, the description carries the burden of behavioral disclosure. It discloses that this is a GET/query operation (safe, read-only) and that it supports pagination and filters. However, it doesn't disclose response format, pagination behavior details, or any rate-limit/error considerations. The read-only nature is implied by 'GET' and 'query' but not explicitly stated.

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

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

The description is two sentences and front-loads the core purpose. It mentions supported features (pagination, filters) without excessive detail. The only minor issue is that 'family-specific filters' is vague and could be expanded or removed.

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 query tool with no output schema and no annotations, the description is adequate but not complete. It covers the operation type and supported parameters, but an agent might need more context on how pagination works, what the response looks like, and how this differs from mcnext_read. The schema covers parameter semantics, but behavioral context is thin.

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 three parameters. The description adds context about pagination and filter capabilities (pageSize, offset, orderBy, family-specific filters), which maps to the query object parameter. However, it doesn't add much beyond what the schema already provides.

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 ('List/filter records') and resource ('collection endpoint'), and clarifies the HTTP method and kind ('GET, kind "query"'). It distinguishes itself from siblings like mcnext_create/mcnext_update/mcnext_delete, though it doesn't explicitly name a sibling alternative for read operations (mcnext_read).

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

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

The description implies usage for querying collection endpoints and mentions pagination/filter support, but it does not explicitly state when to use this tool versus mcnext_read or mcnext_describe_endpoint. It also doesn't mention that endpointId should be discovered via mcnext_list_endpoints, though the schema does.

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

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

With no annotations provided, the description carries the full burden. It discloses the read-only nature (GET, kind 'read') and states the requirement for the path parameter, which are useful behavioral cues. However, it does not mention potential error responses, authentication needs, or rate limits, and it does not clarify whether the operation is safe or idempotent beyond the 'read' label. This is minimal but not misleading, so a score of 3 is appropriate.

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

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

The description is a single, tightly written sentence that front-loads the core action and the critical requirement. There is zero wasted language, and every word contributes to clarity. It is an example of efficient specification.

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 operation with no output schema and no annotations, the description provides the bare essentials but omits context about response format, error handling, or when to prefer this over mcnext_query. It also does not explain that endpointId must be discovered via mcnext_list_endpoints, though that is covered in the schema. Given the simplicity of the tool, it is minimally adequate but could benefit from a sentence on usage context or typical workflow.

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%, so each parameter already has a description. The tool description adds value by explicitly stating 'Requires the path parameter,' which is not marked as required in the schema (only endpointId is). This clarifies a common usage pattern and helps the agent understand that pathParams is typically needed, even if not schema-required. This additional guidance warrants a 4 rather than the baseline 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?

The description states a specific verb ('Fetch'), a resource ('a single record'), and the method ('by id or key, GET'). This clearly distinguishes it from siblings like mcnext_query (which implies multiple records) and mutating tools like mcnext_create/update/delete. It also explicitly labels the operation as a read, leaving no ambiguity about its purpose.

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

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

The description mentions 'Requires the path parameter' but does not explicitly state when to use this tool versus alternatives like mcnext_query. It implies use for single-record retrieval, but lacks explicit exclusions or conditions (e.g., 'for multiple records, use mcnext_query'). The schema does reference mcnext_list_endpoints for endpoint discovery, but that is outside the description, so the guidance is only implied, not explicit.

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

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

No annotations are provided, so the description must carry the behavioral burden. It discloses that the tool modifies a record, supports PATCH or PUT, and specifies PATCH partial-update behavior. However, it does not mention authentication, response shape, idempotency, or whether PUT fully replaces fields, so the behavioral picture is only partially drawn.

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: three short sentences front-load the operation, the required inputs, and the PATCH-specific rule. The phrase 'kind "update"' is slightly redundant, and the requirements sentence is imprecise, but overall the structure is scannable and free of 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 5 parameters, no output schema, and no annotations, the description needs to cover request construction, response expectations, and sibling-tool alternatives. It covers only request essentials and PATCH behavior, omitting response info, PUT full-replacement semantics, and how to distinguish this tool from the many Salesforce update siblings. An agent would still face meaningful uncertainty when invoking it.

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

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

Schema coverage is 100%, so the baseline is 3; the description adds useful context by explaining PATCH partial-update semantics and the need for a JSON body. However, its claim that the path parameter and body are required conflicts with the input schema, where only endpointId is required. This inconsistency weakens the reliability of the parameter guidance.

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

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

The description states a specific verb and resource: 'Update a record (PATCH or PUT)', and the title anchors it to Marketing Cloud Next / Data 360. This clearly separates it from siblings like mcnext_create, mcnext_delete, mcnext_query, and mcnext_read. The 'kind "update"' phrase is redundant, but it does not reduce clarity.

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 establishes clear usage context: update an existing record, with PATCH/PUT semantics and a concrete PATCH rule ('include only the fields to change'). It also names required inputs, though those requirements conflict with the schema's required list. It does not explicitly contrast with alternatives such as mcnext_create or sf_update_record, so it falls short of full when-to-use/when-not-to-use guidance.

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

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

With no annotations, the description carries the full behavioral burden and does well: it discloses the one-call batch limit, the POST endpoint, allOrNone rollback semantics, and automatic splitting of larger inputs. It does not mention response shape or partial-success behavior when allOrNone is false, which keeps it short of a 5.

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

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

The description is three tight sentences with no filler. The core action and limit are front-loaded, and each subsequent sentence adds valuable behavioral or parameter guidance. 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 moderately complex bulk operation with no annotations and no output schema, the description covers the main usage contract well: batch limits, rollback behavior, and automatic splitting. It is close to complete but does not describe what the call returns or how errors from split calls surface, which would make it fully self-contained.

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 sobject, records, and allOrNone. The description adds some context by calling records 'a field map' and explaining the allOrNone effect, but most of this is a restatement of what the schema already provides. 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?

The description opens with a specific verb and resource: 'Create up to 200 records in one call (POST /composite/sobjects).' This clearly describes the operation and distinguishes it from siblings like sf_bulk_update_records and sf_bulk_delete_records by stating the action and endpoint. The bulk scope is explicit, so an agent won't confuse it with sf_create_record.

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 clearly implies this is the bulk-create tool, and the 200-record cap plus automatic splitting tells an agent when its capacity is appropriate. It does not explicitly name alternatives such as sf_create_record for single-record creates, nor does it state when not to use this tool, so it misses the explicit exclusion that would earn a 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?

With no annotations, the description fully discloses the critical behavioral facts: the operation is destructive, it is gated behind an environment variable, it has a 200-record per-call cap, and larger inputs are transparently chunked. This is exactly the side-effect and prerequisite information an agent needs before invoking a delete tool.

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

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

Three short, information-dense sentences front-load the action and limit, then give the destructive warning, then the batching behavior. 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 destructive multi-record tool with no output schema, the description covers the essential operational context: what is deleted, the per-call limit, the guard flag, and automatic handling of larger inputs. An agent has enough to decide whether to invoke it and what to expect.

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 schema descriptions for ids, sobject, and allOrNone are already clear and complete. The description reinforces the ids limit and batching behavior, but does not add significant new meaning 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?

States a specific action on a specific resource: delete up to 200 Salesforce records via the composite sobjects endpoint. The bulk scope and per-call limit distinguish it from single-record delete siblings like sf_delete_record and from bulk create/update tools.

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

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

The description clearly frames when to use the tool: for deleting batches of records up to 200 per call, with automatic splitting for larger inputs. It also flags a prerequisite (MC_NEXT_ALLOW_DESTRUCTIVE=true). It does not explicitly name alternative tools for single-record deletes, so it stops short of a 5.

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

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

With no annotations, the description carries the full burden and does well: it discloses the endpoint, the 200-record cap, the required `Id` field, and the automatic splitting behavior. It does not cover partial-failure or response-shape behavior, which keeps it from a 5.

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, each earning its place: the core capability, the required record shape, and the automatic splitting behavior. 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?

All invocation-critical details are present: endpoint, batch size, `Id` requirement, auto-splitting, and the `allOrNone` option in the schema. The only notable gap is the lack of response/error shape, but since there is no output schema, this 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%, so per the rubric the baseline is 3. The description reinforces that `records` entries need an `Id` plus changed fields and adds batch-size context, but it does not add meaning beyond what the schema already 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?

Clearly states the action ('update'), the resource ('Salesforce records'), and the distinguishing scope ('up to 200 records in one call', PATCH /composite/sobjects). The bulk nature separates it from single-record siblings like sf_update_record and from create/delete bulk 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?

Provides clear context by specifying a batch limit and noting that larger inputs are split automatically. It does not explicitly name alternatives or say 'use this tool instead of X', so it stops short of 5, but the intended use case is unmistakable.

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

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

With no annotations, the description carries the behavioral burden. It discloses the batching limit, the endpoint, and the '@{referenceId.field}' chaining behavior. However, it does not mention side effects of mutating subrequests, allOrNone rollback behavior, or failure/response semantics, which are significant for a tool that can execute arbitrary HTTP methods.

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 sentences with the core capability front-loaded and the reference syntax explained. The phrase 'like Inspector's Composite usage' is a minor distraction for an AI agent, but the rest is tight and 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?

The description is adequate for selection and basic invocation, but with no output schema and no annotations it leaves gaps: it does not describe the composite response shape, per-subrequest status handling, or allOrNone failure behavior. Given the tool's complexity, more context would be needed for fully autonomous use.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real value by explaining the reference syntax '@{referenceId.field}' and the 'one API call' semantics, which are not fully captured by the schema's referenceId description. This helps an agent construct compositeRequest correctly.

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

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

The description names a specific verb ('Execute'), a concrete resource ('up to 25 subrequests in one API call (POST /composite)'), and the distinguishing constraint 'must stay within one API call.' This clearly separates it from single-request siblings like sf_rest_request or the CRUD 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 states the intended context: 'multi-step operations that must stay within one API call.' It does not explicitly name alternatives or give when-not-to-use conditions, but the use case is clear enough for an agent to choose this over single-request 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?

With no annotations, the description carries the behavioral disclosure burden. It does disclose the endpoint, the metadata-change gate (MC_NEXT_ALLOW_METADATA_CHANGES=true), and optional field-level security grants. However, it omits side effects, permission requirements, and reversibility for this mutation operation.

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

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

Three sentences, each carrying distinct information: the action and endpoint, the optional FLS behavior, and the required gate flag. It is front-loaded with the core purpose and contains 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?

The description is adequate for basic invocation, but with 18 parameters, no output schema, and no annotations, it should disclose more about expected responses, error conditions, and permission prerequisites. The gate flag and endpoint help, but an agent is left guessing about post-creation behavior.

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 89%, so the baseline is 3; the schema already documents most parameters well. The description adds value by mentioning field-level security grants, but it does not add parameter-level detail beyond what the schema provides.

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: 'Create a custom field on an object' via the Tooling API. It names the exact endpoint and distinguishes this from sibling tools like sf_create_custom_object and sf_delete_custom_field. The reference to Inspector's Field Creator further clarifies intent.

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

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

The description clearly implies when to use this tool: when creating a custom field on an object. However, it does not explicitly state when not to use it or mention alternatives such as sf_create_custom_object for objects. The gating flag is a useful prerequisite but not a full usage guideline.

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

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

With no annotations available, the description carries the behavioral burden and does so well: it discloses the endpoint, the automatic '__c' suffix derivation, the auto-created Name field behavior, and the feature-flag gate. It lacks details about permissions or failure modes, but otherwise gives strong 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 dense sentences convey the endpoint, naming rule, key side effect, and gating condition with zero filler. The most decision-relevant information is front-loaded.

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

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

For a 9-parameter metadata-create tool with no annotations and no output schema, the description covers the critical behavioral context: endpoint, naming derivation, auto-created Name field, and the required feature flag. Combined with high schema coverage, this is enough to invoke the tool correctly, though return-value details could still be an optional addition.

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 already 89%, and the description adds important relationships not visible in the schema: 'label' (or 'name') drives the API-name derivation, and 'nameFieldType: AutoNumber' suppresses the automatic Name field. This helps the agent understand how the parameters interact.

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

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

The description names the operation ('Create a custom object'), the exact API resource ('CustomObject' via Tooling API), and the POST endpoint, making the tool's purpose unambiguous. It clearly distinguishes this from record-level tools like sf_create_record and field-level tools like sf_create_custom_field.

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

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

The description gives a clear prerequisite (MC_NEXT_ALLOW_METADATA_CHANGES=true) and implies a metadata-creation context, but it never explicitly tells the agent when to choose this over alternatives such as sf_create_record or sf_create_custom_field. An agent must infer routing from the tool name and the phrase 'custom object.'

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

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

With no annotations, the description carries the full behavioral burden. It discloses the operation (POST), the effect (creating a record), and the return value (new record Id). It also warns about field requirements without over-explaining, which is strong for a create tool.

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

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

Two tightly written sentences: the first is action-oriented and states the return value, and the second provides a prerequisite. Every clause earns its place with no padding.

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

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

Given the absence of annotations and an output schema, the description appropriately covers the core invocation details: what is created, how it is called, what is returned, and what to do first. It leaves out error behavior and bulk alternatives, but these are secondary for this tool.

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

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

The schema already documents all three parameters with 100% coverage, so the baseline is 3. The description adds a useful pointer to sf_describe_object but does not add parameter-level meaning beyond what the schema provides.

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 ('Create'), a precise resource ('single sObject record'), and the HTTP endpoint. It establishes the scope as single-record creation, which clearly differentiates it from sibling bulk operations and update/delete tools.

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

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

The description gives clear, actionable context: use sf_describe_object first to check createable and required fields. It does not explicitly exclude alternatives like sf_bulk_create_records, but the word 'single' communicates the intended use case clearly 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?

With no annotations, the description carries the full burden, and it does disclose the HTTP mechanism, the prerequisite ID, and the feature gate. However, it does not explicitly state that deletion is permanent or describe side effects, permissions, or failure conditions, which would strengthen a destructive tool's transparency.

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

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

Three short sentences, each earning its place: the action, the prerequisite, and the gate. No filler or repetition beyond what is necessary.

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 delete operation, the description covers the endpoint, how to get the required ID, and the activation flag. Since there is no output schema, a brief note about the expected response would improve completeness, but nothing critical is missing for invoking the tool.

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

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

Schema coverage is 100%, so the baseline is 3; the description adds extra value by telling the agent how to obtain the fieldId via sf_list_custom_fields, supplementing the schema's format hint with a concrete lookup path.

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, 'Delete a custom field,' and names the exact resource and API endpoint (DELETE /tooling/sobjects/CustomField/{id}). This clearly distinguishes it from sibling tools like sf_delete_custom_object and sf_list_custom_fields.

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 actionable context: it requires the field's Tooling API Id and points to sf_list_custom_fields as the way to find it. It also states the gating flag, but it does not explicitly contrast this tool with deletion alternatives or state when not to use it.

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

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

With no annotations provided, the description carries full burden. It clearly discloses the destructive nature ('removes the object and its data') and the gating condition. However, it doesn't mention irreversibility or any side effects beyond data deletion, which could be more explicit for a delete operation. Still, the key behavioral traits are evident.

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

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

The description is two sentences, front-loading the core action and then adding the prerequisite and gating. Every sentence carries useful information; there is no fluff or repetition. It is concise while covering all key points.

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 delete operation with one parameter and no output schema, the description is complete. It covers what is deleted, how to identify the target, the API used, and a gating condition. Nothing an agent needs to invoke it correctly 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 coverage is 100% and the schema already describes objectId as the Tooling API Id. The description adds value by explicitly stating the requirement and pointing to a method to find that ID (sf_list_custom_objects). This goes beyond the schema's bare description and helps an agent populate the parameter correctly.

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

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

The description clearly states it deletes a custom object via the Tooling API and specifies the exact resource and endpoint. It distinguishes from siblings like sf_delete_custom_field and sf_create_custom_object by naming the specific operation and resource. The mention of the required Tooling API Id further clarifies the scope.

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

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

The description explicitly states the prerequisite (Tooling API Id) and points to sf_list_custom_objects as the way to obtain it. It also discloses the gating condition (MC_NEXT_ALLOW_METADATA_CHANGES=true), which is a clear usage constraint. Though it doesn't name all alternatives, this is strong guidance for an agent.

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

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

With no annotations, the description carries the full transparency burden. It usefully discloses that the operation is destructive and gated behind MC_NEXT_ALLOW_DESTRUCTIVE=true, which is critical behavior. However, it does not mention permanence/recoverability, required Salesforce permissions, or what response or error the caller should expect, leaving material behavioral gaps.

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

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

Two sentences deliver the operation, the HTTP mapping, the destructive nature, and the environment variable gate with zero filler. The core verb and resource are front-loaded, and 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 destructive mutation with no annotations and no output schema, the description communicates the key gate and scope but omits return-value behavior and failure modes. An agent can attempt the call correctly, but it lacks information about success indication, 404 handling, and post-delete effects, so the description is only partially 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?

The input schema already has 100% description coverage for all three parameters, so the baseline is 3. The description's endpoint template {SObject}/{id} mirrors but does not enrich the schema. It adds no new meaning about id format, sobject naming, or the tooling flag beyond what the schema already provides.

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 opens with a precise verb-resource pair: 'Delete a single record', then reinforces it with the exact HTTP endpoint DELETE /sobjects/{SObject}/{id}. 'Single' explicitly distinguishes this tool from bulk delete siblings like sf_bulk_delete_records, and the endpoint makes the operation 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 description gives clear usage context: this is for deleting a single Salesforce record, and it is only usable when MC_NEXT_ALLOW_DESTRUCTIVE=true. It does not name alternative sibling tools or explicitly state when not to use it, but the 'single record' scope plus the destructive guardrail provides enough guidance for correct selection in most cases.

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

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

With no annotations, the description carries the burden. It discloses that includePicklists defaults to false to keep output small, which is a behavioral trait. It implies a read operation but does not explicitly state read-only status, error behavior, or rate limits. It adds moderate transparency beyond 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 two sentences, front-loaded with the key output and immediately followed by practical guidance. Zero filler; every word contributes.

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 describe tool with no output schema and no annotations, it adequately explains what is returned and why to use it. It does not mention tooling API or error handling, but those are covered by parameter descriptions. It provides enough for an agent to call it correctly and interpret the result.

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

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

Schema coverage is 100%, so each parameter is already documented. The description adds extra context for includePicklists (default false to keep output small), which enriches parameter understanding. It also implicitly explains the purpose of the sobject parameter by framing the tool as a metadata getter.

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

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

The description clearly states the action (get metadata) and the resource (sObject), listing specific metadata types (field names, types, labels, picklist values, flags). It also distinguishes itself from siblings like sf_list_objects and sf_soql_query by framing its use as a prerequisite for SOQL and payload building.

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

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

The description explicitly states when to use it ('Essential before writing SOQL or building a record payload'), giving clear context for invocation. It does not explicitly name alternatives or exclusions, but the use-case guidance is strong enough for an agent to choose it over sibling query/list 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?

With no annotations, the description carries the behavioral burden, and 'Fetch' plus 'GET /sobjects/{SObject}/{id}' makes the read-only nature clear. The fields option also signals response-size control. It does not mention not-found behavior or auth requirements, but for a straightforward GET-by-Id operation the core behavior is transparent.

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

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

Two short sentences contain the endpoint, the primary use, and the optional field restriction. The most decision-relevant information is front-loaded and every phrase earns its place.

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

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

For a simple get-by-Id operation with a fully described schema, the description gives enough to invoke the tool and predict its basic behavior. Since there is no output schema, a brief note on the return shape would fully complete the picture, but 'fetch a record' largely covers it.

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

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

Schema coverage is 100%: every parameter already has a meaningful description, so the schema carries the semantic weight. The description adds only the rationale that restricting fields keeps the response small, which is useful but not essential.

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 ('Fetch') and resource ('single record by Id'), and also gives the exact REST endpoint pattern. This clearly distinguishes it from siblings like sf_soql_query, sf_create_record, and sf_update_record, which have different targets and verbs.

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?

'Fetch a single record by Id' provides clear invocation context: use this when you already have a record Id and need one object. It does not explicitly name query or rest_request as alternatives, which keeps it just below a 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?

With no annotations provided, the description must carry behavioral disclosure. It implies a read-only list operation but does not explicitly state that it has no side effects or discuss rate limits or pagination. The mention of Tooling API SOQL gives some context, but it does not go beyond the obvious.

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

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

The description is two sentences with no fluff. It front-loads the purpose and provides a practical pointer to a sibling tool. Every word earns its place.

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

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

The description is adequate for a simple list tool: it states what is returned (custom fields with Ids) and how to use the result. The schema covers parameter details. It could be slightly more explicit about the output structure, but that is not critical given the simplicity.

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?

All three parameters (limit, search, sobject) are fully described in the schema (100% coverage). The description adds no additional parameter semantics, so it meets the 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?

The description clearly states the action (list), the resource (custom fields), and a distinguishing detail (Tooling API Ids). It also specifies the underlying method (SOQL query on CustomField). This distinguishes it from sibling tools like sf_list_objects or sf_list_custom_objects.

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

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

The description implies usage for enumerating custom fields but does not explicitly contrast with alternatives. It only mentions a follow-up tool (sf_delete_custom_field) without stating when to use this tool versus others, so the agent must infer the appropriate context.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It does add useful context by revealing that this runs 'a Tooling API SOQL query on CustomObject' and returns Tooling API Ids. It does not explicitly confirm read-only behavior, ordering, or output shape beyond the Ids, but 'List' and 'query' imply a non-mutating operation.

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

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

The description is two sentences with no filler. The primary purpose is front-loaded, and the downstream usage hint ('Use the returned Id with sf_delete_custom_object') is a valuable, compact addition.

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

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

For a simple list tool with no output schema and no annotations, the description provides the core information: what is listed, how it is queried, and what the returned Ids are for. It does not detail every return field, but the stated purpose of obtaining Tooling API Ids is sufficient for the intended use.

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

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

Schema description coverage is 100%: both 'limit' and 'search' already have meaningful descriptions in the input schema. The tool description adds no additional parameter-level detail, 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?

The description states a specific action ('List'), a clear resource ('custom objects in the org'), and a key output detail ('Tooling API Ids'). It also distinguishes this from general object listing by specifying custom objects and the Tooling API query mechanism.

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 a usage context by saying 'Use the returned Id with sf_delete_custom_object,' which helps the agent understand one downstream purpose. However, it does not explicitly state when to prefer this tool over siblings like sf_list_objects or sf_soql_query, nor does it mention 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?

With no annotations provided, the description carries the burden of explaining behavior. It discloses that this is a global describe and specifies the returned fields (name, label, key prefix), but it does not mention pagination, performance implications, or any filtering behavior beyond what the schema already 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?

Three short sentences each carry distinct value: what the tool does, what it returns, and when to use a sibling tool. The information is front-loaded and there is no redundant or filler 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 simple list tool with no output schema, the description covers the key return shape and the main alternative. It could mention how search interacts with the global describe, but that is already covered by the input schema, so the description is largely 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%, so the parameters search and tooling are already documented. The description adds no additional meaning about parameter usage, so a 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 specific verb ('List'), a clear resource ('the sObjects in the org'), and the method ('global describe'). It also differentiates itself from the sibling tool sf_describe_object by noting the tools covers listing vs. field-level detail, making the tool's purpose 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 description provides explicit guidance to use sf_describe_object when field-level detail is needed, giving the agent an alternative route. It does not mention exclusions or when to prefer other sibling list tools like sf_list_custom_objects, but the context is clear enough for this tool's scope.

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

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

No annotations are provided, so the description carries the full burden. It explicitly states it 'Reads' the limits, implying a non-destructive operation. It doesn't disclose any additional behavior such as authentication requirements, rate limits, or return format. For a simple read operation, the description is adequate but not rich; it provides the endpoint (/limits) and examples but omits details about response structure.

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

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

The description is two sentences with no filler. It front-loads the core action ('Read the org's governor limits and current usage') and follows with a practical use case. Every word serves a purpose, making it highly efficient.

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

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

For a read-only tool with one optional parameter and no output schema, the description covers the essential information: what it does, examples, and a practical use case. It doesn't describe the response structure, but since the tool name and description are clear, this is a minor gap. Given the simplicity, it is sufficiently 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?

The schema description coverage is 100%, and the schema already documents the 'filter' parameter clearly ('Only return limits whose name contains this string (case-insensitive).'). The description does not mention the filter or add any extra semantic meaning beyond what the schema provides. With full schema coverage, 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 clearly states the tool reads the org's governor limits and current usage, with specific examples like DailyApiRequests, DataStorageMB, and FileStorageMB. It uses a specific verb ('Read') and resource ('org's governor limits and current usage'). It doesn't explicitly differentiate from siblings like sf_rest_request, but the purpose is unambiguous enough to distinguish it as a dedicated limits reader.

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

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

The description provides a clear use case: 'Useful for checking remaining API quota before bulk work.' This gives an agent context on when to invoke it. However, it doesn't mention alternatives or explicitly state when not to use it, leaving some room for interpretation.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It does transparently state that any method can be used, including potentially destructive ones, and clarifies path resolution rules. However, it does not mention authentication requirements, error behavior, or explicit warnings about mutating/destructive operations beyond the unadorned 'any method' phrase.

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

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

The description is three sentences with no filler. It front-loads the core purpose, follows with path-format examples that resolve ambiguity, and ends with a directive on when to use it. 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 generic REST explorer with no output schema, the description adequately conveys the tool's purpose, path syntax, method flexibility, and fallback role. It does not detail the response format, error semantics, or rate limits, but these are less critical for a raw endpoint caller and the provided information is sufficient 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 coverage is 100%, so the baseline is 3. The description adds meaningful semantic detail about the most ambiguous parameter, 'path', by explaining that it can be either relative to /services/data/vXX or an absolute /services/data/... path, and provides concrete examples. This goes beyond the schema's own description.

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

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

The description states a specific verb ('Call'), a well-defined resource ('any path under /services/data/vXX'), and any HTTP method, with examples of both relative and absolute paths. It explicitly distinguishes itself from siblings by positioning itself as the generic fallback for endpoints not covered by other tools, making it easy for an agent to recognize when this tool is the right choice.

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 an explicit usage condition: 'Use this for endpoints not covered by the other tools.' This directly tells an agent when to select this tool over siblings, and implicitly when not to use it, without requiring the agent to inspect other tool schemas.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It does disclose the return fields ('records', 'done', 'nextRecordsUrl') and pagination behavior, which is useful. However, it omits any mention of side effects (or lack thereof), permission requirements, rate limits, or error behavior, leaving gaps for a tool with no annotation coverage.

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 sentences, each earning its place: the first states the core action, the second explains pagination and directs to the sibling, and the third gives a concrete example. The most important scoping information is front-loaded.

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

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

For a two-parameter tool with 100% schema coverage and no output schema, the description covers the key return shape and pagination flow, which is what an agent needs to call it and handle the response. It could additionally mention error conditions or overall result size limits, but these are secondary for a straightforward query tool.

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

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

Schema description coverage is 100% for both 'soql' and 'tooling', so the structured schema already explains the parameters. The description adds an example query but that example duplicates the one already in the schema, providing no additional parameter semantics beyond what the schema offers.

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 ('Execute'), a concrete resource ('SOQL query against the org'), and even identifies the underlying REST endpoint. It clearly distinguishes itself from sf_soql_query_more by explaining that this tool returns pagination fields and that the sibling handles subsequent pages.

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 an explicit alternative: 'Use sf_soql_query_more to fetch the next page.' This tells the agent exactly when not to use this tool and which sibling to call, which is the core selection guidance needed for pagination.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It discloses the core behavior (fetching the next page) and the dependency on a prior URL, but does not mention error behavior, whether further pagination URLs are returned, or the side-effect-free nature beyond the word 'Fetch'.

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 sentence with a front-loaded verb and no filler. Every word contributes to the meaning, and the structure is immediately scannable.

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 tool with no output schema, the description states the source of the required URL and the purpose. It does not detail response shape or pagination termination, but the operation is simple enough that the description is adequate.

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

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

Schema coverage is 100% and the parameter already has a description and example. The description adds the relational context that the URL comes from `sf_soql_query`, but does not add significant new parameter-level meaning, so the baseline score of 3 applies.

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

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

States a specific verb ('Fetch') and resource ('next page of results') and explicitly ties it to `nextRecordsUrl` returned by `sf_soql_query`. This clearly distinguishes it from the initial-query sibling and leaves no ambiguity about what the tool does.

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

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

Provides clear context: this is the follow-up pagination tool for a prior `sf_soql_query` call. It does not explicitly list when-not-to-use or alternative tools, but the dependency on `nextRecordsUrl` makes the usage boundary obvious.

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

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

With no annotations, the description carries the behavioral burden. It does disclose meaningful traits: the operation is a PATCH (partial update), only provided fields are changed, and success returns 204 No Content. However, it omits permissions, error behavior, or side-effect details, so the transparency is adequate but incomplete.

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 short sentences with no filler. The core operation and endpoint are front-loaded, followed by the key usage rule and the success response, making every sentence earn its place.

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

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

For a simple update tool with a well-covered schema and no output schema, the description provides the essential return information (204) and the partial-update semantics. It is complete enough to invoke correctly, though error cases and permission requirements are not addressed.

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

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

The input schema already covers all 4 parameters at 100%, giving a baseline of 3. The description adds value beyond the schema by clarifying partial-update semantics: 'Pass only the fields you want to change' tells the agent the fields object is not a full replacement payload.

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: 'Update a single record' with the Salesforce REST endpoint PATCH /sobjects/{SObject}/{id}. The 'single record' qualifier clearly distinguishes it from bulk update siblings like sf_bulk_update_records.

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 provides clear context: update one record via PATCH, and 'Pass only the fields you want to change' gives practical invocation guidance. It does not explicitly name alternatives or when-not-to-use scenarios, but the single-record framing makes the intended scope evident relative to bulk tools.

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