Inngest MCP by usefulapi

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

Annotations only declare destructiveHint=true, and the description adds substantial value on top: it warns this STOPS IN-FLIGHT WORK across production functions, advises tight scoping, and clarifies that completed runs are untouched. It still omits whether the action is reversible/what the delete sibling does with the result, so it falls short of the fullest 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?

Three short sentences, the destructive scope stated up front with capitalization for emphasis, then the boundary condition, then the API endpoint. 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?

The tool is well covered for a destructive bulk operation with no output schema, and the endpoint hint is useful. What is missing is any hint about what comes back (e.g. a cancellation identifier that the sibling inngest_delete_cancellation would consume), which an agent would want when deciding whether to chain 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 description coverage is 100%, so every parameter including the CEL 'if' filter is already documented in the schema; the description only restates the time window and event-expression narrowing at a high level. Baseline 3 is appropriate when the schema carries the semantic load.

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 (cancel every run of one function), plus the scoping dimensions (time window, event expression). The verb/scope combination clearly separates it from the sibling list/delete cancellation tools, so an agent can select it 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?

Gives clear context for when the tool applies (in-flight runs inside a window) and an explicit warning to narrow the window tightly, plus the important boundary that already-finished runs are unaffected. It does not, however, name the alternative tools (e.g. inngest_list_cancellations to preview, or inngest_delete_cancellation to undo), so exclusions and alternatives are left implicit.

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 supply destructiveHint=true; the description adds genuinely new semantics by clarifying that the deletion is partial in effect — 'Runs it already cancelled stay cancelled' tells the agent this is not a rollback. It stops short of stating permission requirements or what the response contains, but the non-reversibility note is the key behavioral fact.

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, and the effect of the call is front-loaded ahead of the semantics caveat and the endpoint. Every sentence carries distinct 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 one-parameter destructive delete with annotations covering the safety profile and no output schema, the description supplies purpose, partial-effect semantics, and the endpoint. It is nearly complete; only the source of cancellation_id and any auth expectations are unaddressed.

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

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

With a single parameter and 100% schema description coverage, the schema already documents cancellation_id as 'The cancellation job's id.' The description adds nothing about format or where to obtain the id, so the baseline 3 applies rather than a higher score.

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

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

States a specific verb and resource ('Delete a bulk-cancellation job') plus the effect ('so it stops cancelling further runs'), which lets an agent separate it from inngest_create_cancellation and inngest_list_cancellations without reading their schemas. The REST mapping reinforces exactly which resource is touched.

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 'so it stops cancelling further runs' implies the intent behind calling it, but the description never states the conditions for choosing this over siblings such as inngest_list_cancellations (to find an id) or a hypothetical resume/pause alternative. Usage is inferable, 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?

Annotations declare destructiveHint=true, so safety is partly covered; the description adds real behavioral value by disclosing the immediate downstream effect on the external event source. It stops short of stating irreversibility, permission requirements, or what happens to already-queued events.

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 impact statement precedes the raw API mapping, which is a compact and useful reference.

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 destructive tool with no output schema and destructiveHint already declared, the description covers the essential impact. It could be stronger by explicitly noting that deletion is irreversible and whether events already in flight are retained.

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 one parameter with 100% schema description coverage, so the schema already explains webhook_id adequately. The description adds no format, sourcing, or constraint details beyond the schema's baseline.

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

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

States a specific verb and resource ('Remove a webhook ingress'), which cleanly separates it from the get/list/create webhook siblings. An agent can identify the operation without consulting 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?

Usage is only implied by the verb and the consequence sentence ('The external source stops producing events immediately'). No explicit when-to-use, when-not, or named alternatives among siblings are given.

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 return-shape context (name, payload, timestamp) and maps the operation to the underlying REST endpoint, which is genuinely useful given no output schema exists.

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

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

Two compact sentences: the outcome and returned fields come first, the endpoint mapping second. Nothing is wasted and the key 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 single-parameter read tool with no output schema, the description covers what is fetched and what fields come back, which is enough for correct invocation. Only the when-to-use routing 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 single event_id parameter is fully documented as a ULID in the schema. The description adds no parameter detail beyond restating {eventId} in the endpoint path, 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 (Fetch) and resource (a single event) plus the fields returned. It implicitly contrasts with sibling inngest_list_events by emphasizing 'single', but does not name the alternative explicitly.

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 vs. inngest_list_events or inngest_list_event_runs, and no prerequisites or error conditions mentioned. The only hint of scope is 'single event', which is left for the agent to infer.

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 marks this as a safe read, so the burden is light. The description does add value by naming the response contents (status, output, error), which is useful given there is no output schema, but it says nothing about behavior on a missing run, error cases, or auth.

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 returned fields are stated before the API reference. The trailing "Inngest: GET /v1/runs/{runId}" line is a useful anchor rather than 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?

For a single-parameter read tool whose schema is fully documented and which has no output schema, the description covers purpose, the identifier, and the returned fields. Only edge-case behavior (missing run, auth) is absent, which is a minor gap.

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

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

Schema description coverage is 100%, so the sole run_id parameter is already documented as a ULID. The description adds only the endpoint path template, which is marginal; the baseline of 3 applies when the schema carries the parameter meaning.

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

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

States a specific verb and resource ("Fetch a single function run") and enumerates what it returns (status, output, error), which cleanly separates it from list-style siblings like list_run_jobs and list_event_runs. It stops short of explicitly naming a sibling it is not, 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?

The description says what it does but never says when to use it versus siblings, nor how to obtain a run_id (e.g., via list_event_runs). No prerequisites, no exclusions, no alternative routing is supplied.

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 meaningful context beyond that by disclosing what the call returns (the ingress URL and its transform), which matters because no output schema exists. It stops short of noting failure behavior for a missing or invalid id.

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

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

Two short sentences, zero waste. The core action leads and the API mapping trails, so nothing important is buried.

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

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

For a one-parameter read with no output schema, the description covers purpose and return shape, which is what an agent needs to invoke it correctly. Only error/not-found semantics are left implicit, a minor gap at this complexity level.

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

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

The single webhook_id parameter is fully documented in the schema (100% coverage), so the schema carries the burden. The description only echoes that a webhook id is required implicitly via the path, adding no format or constraint 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 ("Fetch") and resource ("a single webhook ingress"), and the qualifier "single" cleanly differentiates it from the sibling inngest_list_webhooks and inngest_delete_webhook. It even adds the underlying API route, so an agent knows exactly what operation this maps to.

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: fetch one webhook when you have its id. There is no explicit statement of when to prefer this over inngest_list_webhooks or what happens if the id is unknown. Adequate but no exclusions or alternatives named.

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 establishes this as a safe read, so the description isn't carrying the safety burden. It adds that results include job 'progress', which tells the agent something about returned content, but says nothing about pagination behavior beyond what the cursor parameter implies.

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, purpose front-loaded, and the endpoint mapping appended without padding. Nothing extraneous.

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

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

For a simple read-only list tool with a fully documented two-param schema and no output schema, the description covers purpose and result content adequately. It could note that results are cursor-paginated, but the schema already conveys that.

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

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

Schema description coverage is 100% — both 'limit' (page size 1-100) and 'cursor' (from previous page) are fully documented in the schema. The description adds no additional parameter meaning, 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 and resource ('List bulk-cancellation jobs') and adds the useful scope detail 'their progress'. It implicitly distinguishes from the create/delete cancellation siblings by being the read/list operation, but never names them explicitly.

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, and no mention of alternatives such as inngest_create_cancellation for starting a job or inngest_delete_cancellation. The agent must infer the role of this tool purely from the name and 'list' verb.

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 each returned run carries a status and maps the operation to the REST endpoint GET /v1/events/{eventId}/runs, which is useful context. It says nothing about pagination, result limits, or behavior when the event triggered no runs, so it remains at the baseline for an annotated 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 sentences with the core action front-loaded and the endpoint last. The middle sentence is somewhat rhetorical but does orient the agent conceptually; no filler otherwise.

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 read-only list tool with no output schema, the description supplies the key return-shape hint (runs plus their statuses) and endpoint mapping. Missing only pagination/volume expectations, which is a minor gap given the tool's simplicity and its readOnlyHint.

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

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

Schema coverage is 100% and the single event_id parameter is documented in the schema itself. The description adds no format, source, or lookup guidance for the id beyond what the schema states, so 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 states a specific verb and resource: 'List every function run one event triggered, with each run's status.' That scope ('runs one event triggered') implicitly separates it from siblings like inngest_list_events (all events) and inngest_get_run (a single run). It stops short of naming an alternative explicitly, so it lands just below the top tier.

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

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

The 'hop from this event arrived to and here is what it did' framing implies the use case (drill from an event into its downstream runs), but no when-to-use condition, exclusion, or named alternative is given. 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 establishes the safe read profile, and the description usefully adds sort order (newest first) and environment scoping. It stops short of any behavioral detail beyond that – no note on default page size, rate limits, or what fields come back in each event.

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 tight sentences, front-loaded with the core action and scope, then the investigative framing, then the endpoint mapping. No sentence is filler.

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

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

For a simple read-only, two-parameter list tool, the description covers what it returns, the ordering, and the scope, with pagination handled by the schema. The only real gap is that no output schema exists and the shape of a returned event is not sketched.

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 both parameters (limit, cursor) are fully documented in the schema, so the baseline is 3. The description contributes nothing additional about pagination semantics or cursor behavior.

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

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

States a specific verb and resource (list the events) plus scope (in the key's environment) and ordering (newest first), which an agent can act on immediately. It implies an entry-point role but never explicitly names sibling alternatives like inngest_get_event or inngest_list_event_runs, so differentiation is left to inference.

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?

'Events are what start functions, so this is where an investigation begins' gives a clear use context for reaching for this tool first. It never states when not to use it or names the alternative for drilling into a single event or its runs, so no explicit routing is provided.

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 establishes this is a safe read. Beyond that, the description discloses what the response carries ('status and timing') and maps the tool to the underlying endpoint GET /v1/runs/{runId}/jobs, adding real context about the result shape. It does not mention pagination or ordering, so not 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?

One sentence, front-loaded with the action and subject, with the failure-diagnosis rationale and endpoint mapping appended compactly. No sentence is wasted.

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

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

With a single required parameter and no output schema, little is demanded of the description, and it does describe the return content (status and timing). It could say more about pagination or step ordering for a list endpoint, so it is strong but not exhaustive.

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 the single run_id parameter, so the schema already carries the parameter meaning. The description only echoes the id via the URL template and adds no format or constraint details beyond that. Baseline 3 is appropriate.

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

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

States a specific verb and resource ('List the individual steps (jobs) of one run') and immediately disambiguates the jargon by equating steps with jobs. It is clearly distinct from the sibling inngest_get_run, which returns the run itself rather than its constituent steps.

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 'how you find which step of a durable function failed' gives a concrete diagnostic use case, which is far more than implied usage. It stops short of naming the alternative tool or stating when not to use it, so it falls 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?

readOnlyHint=true already establishes the safe-read profile, so the description's burden is lighter. It adds the domain meaning of a webhook but says nothing about result ordering, pagination behavior beyond the cursor param, or whether the list is scoped/limited.

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

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

Two compact clauses with the purpose front-loaded and the REST endpoint appended as a useful identifier. No filler, though the endpoint reference is optional garnish.

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?

A simple read-only list tool with fully documented parameters and no output schema, so return values need not be explained. Only minor gap is absent guidance on paging/ordering beyond the schema's cursor description.

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%, with limit and cursor both documented in the schema itself. The description adds no parameter meaning, 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 (List) and resource (webhook ingresses in the environment) and clarifies what a webhook is: 'external sources that turn into events.' This cleanly distinguishes it from siblings like get_webhook and delete_webhook.

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 listing intent implies when to use it, but there is no explicit routing: it never says to use get_webhook for a single webhook or names any alternative. 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.