DeckCraft MCP Server

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

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false, and openWorldHint=false, so the safety profile is covered; the description is consistent with that. It adds the useful context that inputs may be a single file, a list, or a whole folder, but says nothing about whether existing outputs are clobbered, how large batches behave, or what is returned. No contradiction with annotations.

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

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

A single front-loaded sentence that begins with the verb and then enumerates inputs and outputs; dense but every clause carries information. Slightly long for one sentence, though nothing is redundant.

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

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

Given a non-read-only file-producing tool with no output schema, the description does the essential work of spelling out the full input/output format matrix that an agent needs to pick valid formats values. Remaining gaps (overwrite semantics, return payload) are either covered by the schema (overwrite) or minor for a conversion utility.

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 64%, and the description usefully explains the formats enum (pptx, pdf, deckcraft, png/jpeg, outline) and the pdf layout options (slides/notes/handouts) at a high level. It leaves scale, suffix, overwrite, output_dir/output_path, handouts_per_page, and input_dir/input_paths unaddressed, so it only partially compensates for the coverage gap.

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 (convert) plus the resource (presentations), and enumerates both accepted input formats (.pptx, .deckcraft) and every output format, so an agent knows exactly what the tool produces. It does not, however, differentiate itself from the overlapping sibling render_slides, which likely also turns slides into images.

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 lists capabilities but never says when to choose this tool over render_slides, edit_presentation, or create_presentation, nor any precondition (e.g. file must already exist, output_dir needed for new files). Usage must be inferred purely from the format list.

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=false, destructiveHint=false and idempotentHint=false, so the write-not-read profile is covered. The description adds genuinely new context by disclosing the written artifact set (pptx/pdf/deckcraft/png/jpeg/outline) and that it returns preview pictures of the first slides, but it says nothing about overwriting existing files, where output lands, or failure modes.

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?

Purpose is front-loaded, but the body is a single semicolon-chained run-on sentence enumerating nearly every feature and format, which is dense and hard to scan. Much of the enumeration duplicates what the schema already states, so those clauses do not fully earn their place.

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

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

There is no output schema, so the description does well to name the produced formats and the returned preview images. However, for a 20-parameter creation tool it omits practical essentials such as needing absolute output paths for new files and what happens when overwrite is false, leaving real gaps.

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

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

Schema description coverage is 90% and every one of the 20 parameters is documented inline, so the schema carries the load. The description only echoes the feature categories at a high level (theme, colour and font schemes, slide size, slide numbers and footer, speaker notes, transition and bullet animation) without adding syntax or default details 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?

Opens with a concrete verb+resource ('Build a slide deck with DeckCraft') and enumerates both accepted input modes (a list of slides or a plain-text outline) plus the output formats. It is unambiguous what the tool does, but it never distinguishes itself from siblings like edit_presentation or convert_presentation, so an agent must infer this is the creation path.

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

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

Usage is only implied: the tool is for building a deck from scratch, with 'outline' offered as an alternative to the slides array. There is no explicit when-to-use/when-not guidance and no reference to the sibling tools an agent should prefer for editing an existing deck or converting formats.

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 readOnlyHint=false and destructiveHint=false; the description adds genuinely useful behavior beyond that by stating 'Saved as new copies; the originals are only read', clarifying that edits do not mutate sources. It still omits permission/auth needs and whether an existing output is silently skipped vs overwritten.

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?

Front-loads the core purpose and then lists capabilities compactly, with the important non-destructiveness note in a short closing sentence. The middle enumeration is dense but every clause names a genuine capability, so there is little waste.

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

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

For a 25-parameter mutation tool with no output schema, the description gives an accurate capability map and clarifies the read-only-to-source behavior. It leaves gaps around how the many optional parameters interact (e.g. add_at vs delete_slides ordering), but the schema carries much of that detail.

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 72%, and the description conceptually names many operations (replace text, theme, colour/font scheme, speaker notes, transitions, slide numbers, footer) that map to parameters. However it adds little syntax or format detail beyond what the schema already documents, so it lands at the 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+resource ('Open ... presentations and change them') and enumerates concrete operations: find/replace, theme/colour/font scheme, add/delete slides, notes, transitions, footers. It also distinguishes itself from siblings by referencing create_presentation for add-slide semantics and by noting outputs are new copies.

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

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

Usage is implied by the enumerated capabilities, and it cross-references create_presentation for slide-adding semantics, but it never states when to choose edit_presentation over convert_presentation, render_slides or run_deckcraft_commands. No explicit alternatives or exclusions 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, idempotentHint=true, openWorldHint=false and destructiveHint=false, so the safety profile is covered. The description still adds value by disclosing the inspection scope, notably that it probes live state ('whether the app is running / listening for control') rather than just static install info.

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

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

A single front-loaded sentence with the verb and target first, followed by a compact enumeration of the checked items; no filler. The trailing list is slightly run-on but every item conveys real scope 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?

With no output schema, the description carries the burden of indicating what the agent will get back, and the enumeration of platform, executables, version, commands, themes, formats and running state effectively sketches the return content. It stops short of describing structure or how to interpret a failure, but is adequate for a simple status probe.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for 0-param tools applies. No parameter-related ambiguity is introduced by the 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?

States a specific verb ('Check') and resource ('the DeckCraft installation') and then enumerates exactly which facets are inspected: platform, executables, version, engine commands, themes, formats, and running/listening state. This is clearly distinguishable from sibling tools such as get_presentation_info (which targets a presentation) or run_deckcraft_commands.

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 diagnostic framing ('Check the DeckCraft installation') implies this is the tool to call to verify readiness, but there is no explicit when-to-use statement, no mention of it being a prerequisite before run_deckcraft_commands or open_in_deckcraft, and no exclusions. Usage must be inferred.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=false and destructiveHint=false, so the safety profile is covered. The description adds genuinely useful behavioral context by enumerating the full scope of what is returned (shapes with ids, tables, charts, notes, transitions, theme, sections), which is what an agent needs since 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 sentences, front-loaded with the return content and ending with the optional capability. The long comma-separated inventory is dense but each item is substantive 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?

With no output schema, the description carries the burden of describing return content and does so thoroughly. The remaining gap is that it says nothing about the input (input_path) or how results relate to the sibling tools, but for a straightforward read-only inspector this is close to 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 67%, and the description reinforces the 'review' flag ('Optionally a spelling and accessibility review') and the scope of shape enumeration. It does not explain the 'details' toggle or the input_path format, so it adds only marginal meaning beyond the schema's own parameter 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 names the resource precisely (slides of a PowerPoint or DeckCraft file) and enumerates exactly what is extracted, so an agent knows this is a read/inspection tool. However, it never explicitly differentiates itself from siblings like get_deckcraft_status or render_slides, so the agent must infer the boundary.

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

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

There is no when-to-use guidance, no statement of when an alternative (e.g. render_slides or get_deckcraft_status) is preferable, and no prerequisites. The only usage hint is the word 'Optionally' attached to the review capability, which is really a parameter note rather than routing guidance.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is fully covered. The description adds the useful fact that this is a discovery surface (what commands exist, with their parameters and ribbon placement), but says nothing about return volume, filtering/pagination behavior, or how large these catalogs get.

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 dense sentence with the resource declared first and the capability list front-loaded in parentheses. Every clause carries information; only the nested parentheticals make it slightly scannable-hostile.

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, low-complexity discovery tool with no output schema, the description gives a decent sense of what each kind returns, but does not sketch the shape of entries (id/label/category fields) or note that filter matches across id, label, place and category as the schema states. Adequate but leaves the agent guessing about result structure.

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

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

Schema coverage is 50%: 'filter' is documented in the schema, while 'kind' has only an enum. The description compensates partially by explaining what each enum kind actually contains (commands carry parameters and ribbon place, shapes are preset names, etc.), which adds real meaning for 'kind'. But it never mentions the 'filter' parameter or how it interacts with the chosen kind, leaving half the parameter surface schema-driven.

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 resource (a DeckCraft capability catalog) and enumerates exactly the seven kinds it can return, so an agent knows precisely what it fetches. It even cross-references the sibling consuming one kind ('for run_deckcraft_commands'). It stops short of a crisp verb-first statement ('List...'), but the intent is unambiguous against siblings.

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

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

There is an implicit discovery-then-invoke flow and one useful routing hint that command data feeds run_deckcraft_commands, which implies 'call this before building commands'. However, it never states when to use this tool versus alternatives, nor any exclusions or prerequisites.

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

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

Annotations already cover the mutation surface (readOnlyHint=false, destructiveHint=false, openWorldHint=false). The description adds genuinely non-obvious behavior: control=true spins up a loopback-only control channel, which tells the agent about a network/security side effect it could not infer from the schema. It omits launch failure behavior and whether the call blocks until the app loads.

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, both load-bearing: the first gives purpose, the second gives the one non-obvious mode and its downstream dependency. No filler or restatement of the title.

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

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

For a two-parameter, no-output-schema tool the description covers the essential decision (control on/off and why). It could still note what a successful open returns (e.g., confirmation vs. handles) or whether the app must already be installed, but nothing critical 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 50% because 'control' has no schema description at all; the description compensates by explaining that control=true activates the loopback control channel. 'paths' is left to the schema's own wording, which is adequate but nothing extra is added about ordering, duplicates, or the 20-file cap 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 concrete verb and resource ('Open presentations in the DeckCraft desktop app') plus the intent (present or keep editing by hand), which cleanly separates it from the API-oriented siblings like edit_presentation. An agent can identify the tool 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 an explicit conditional for the non-default mode: set control=true when you intend to drive the app via run_deckcraft_commands with live=true. It does not say when to prefer this over create_presentation/edit_presentation or what happens if the desktop app is unavailable, so it stops short of a full when/when-not matrix.

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

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

Annotations already declare readOnly, idempotent, closed-world and non-destructive behavior. The description adds value beyond them: a hard cap of 8 returned images and the fact that save=true writes PNG files named <name>_s<N>.png, so the agent knows a disk side effect exists despite readOnlyHint.

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 dense sentence with no filler, and the core capability plus the two most decision-relevant facts (8-image cap, PNG-on-save) are front-loaded. Slightly awkward grammar costs it the top mark.

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

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

For an 8-parameter tool with no output schema, one sentence is thin. It never says what is returned when save=false (presumably inline images), what happens when the selection exceeds the 8-image cap, or how slides interacts with the ordering of outputs.

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 63%, mid-range. The description explains only one parameter's effect (save=true yields PNGs with a naming pattern); scale, slides, overwrite, output_dir, output_path and save_scale are left entirely to the schema. Adds marginal meaning without compensating for the uncovered parameters.

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

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

States a concrete verb-and-resource outcome: producing pictures of slides from a PowerPoint or DeckCraft file, with the output count and file naming. It distinguishes itself from read-oriented siblings like get_presentation_info or open_in_deckcraft, though the phrasing 'Pictures of slides ... to look at them' is roundabout rather than a clean verb+object.

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 alternatives named among the many siblings (convert_presentation, get_presentation_info, open_in_deckcraft). The only implicit cue is that this is the way to visually inspect slides.

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 destructive=true, readOnly=false and idempotent=false, so the safety profile is covered. The description goes further by disclosing execution semantics (steps run in order, stop-on-first-error by default), the live-vs-headless switch, and the save step. It does not restate the destructive/overwrite implications, but the added batch and mode context 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 core behavior is front-loaded ('Advanced: run any DeckCraft engine commands in order'), followed by the command families, the step-reference rule, coordinate units, and the live flag — each contributing real information. The long single-paragraph enumeration of command families is dense, but none of it 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 14-parameter batch executor with a nested steps array and no output schema, the description covers the essential mental model: what steps are, how to reference prior results, how coordinates work, and the live/headless distinction. It does not describe the return payload or save/overwrite outcome in detail, which is the main remaining gap given the absent output schema.

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

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

Schema coverage is only 57%, so the burden to compensate is real, and the description does add non-schema semantics that are critical to correct use: step ids map to tool names, parameters can reference prior results via '$steps[N].field', and coordinates are in points (16:9 = 960x540). It still leaves several parameters (name, formats, output_dir, preview_slides) unexplained, but the mechanism-level additions are valuable.

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 gives a specific verb and resource ('run any DeckCraft engine commands in order') and enumerates the command families and engine tools it accepts, so an agent knows exactly what this does. It is clearly a batch/advanced executor on a new or opened presentation. However it never explicitly contrasts itself with edit_presentation or create_presentation, so sibling 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?

The 'Advanced:' marker and 'on a new or an opened presentation, then save' give implicit context for when to reach for this tool rather than the simpler siblings. But it never states when NOT to use it or names edit_presentation/create_presentation as the alternatives for single edits. Usage is implied rather than spelled out.

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