Coda MCP demonstrates solid tool design with clear, domain-specific naming (coda_*), well-structured schemas, and comprehensive descriptions. All 8 tools have explicit input schemas with proper JSON Schema format and type definitions. Descriptions average ~180 chars, within the 10-1024 baseline. However, parameter descriptions are sparse, most parameters lack inline help text (e.g., coda_apply_plan's complex 'plan' parameter is undocumented; coda_get_link's 'include_json' and 'full_link' have minimal guidance). Error handling is present but generic ('Refused, so nothing was applied'). No tool annotations (readOnlyHint, destructiveHint, idempotentHint) despite clear risk profiles. Output schemas are not formally documented, responses are text-based rather than structured JSON objects, forcing LLMs to parse prose.
Edit the draft with a plan: nodes to add, params to set, wires to make or cut, nodes to remove. The plan is applied whole or refused whole, and a refusal names every problem. Existing nodes are named by the ids coda_describe_draft shows; new ones by refs you invent in this plan.
Every problem the cards in Coda would show for the draft, errors first. Checking does not run the workflow: it catches wiring, types, missing params and columns that are known before any data arrives.
The draft as it stands: every node id and type, the columns each output carries, params that differ from their defaults, the options a param offers as wired, every wire, and every problem the cards would show.
A link that opens the draft in Coda. Give it to the user exactly as returned. Check the draft first; a link to a draft with errors opens with those cards marked. The link is short, and stores the draft on this server.
Read before the first edit. Coda's own rules for writing a plan, then the catalogue of every node type with its ports and params. `lean` omits most param help; use coda_node_details for one node's full help.
coda_apply_plan schema is opaque: inputSchema is delegated to coda.planSchema() with no visible parameter documentation. LLMs cannot infer what fields the 'plan' object accepts, their types, or constraints. This violates the pattern:constrained-input and pattern:tool-description rules.
No tool annotations despite clear risk profiles. coda_new_draft, coda_apply_plan, and coda_undo are write/reversible operations; coda_guide, coda_describe_draft, coda_check_draft are read-only. Missing readOnlyHint and destructiveHint annotations prevent LLMs from reasoning about safety and retry logic.
Output schemas are not documented. All tools return text-based CallToolResult with prose descriptions. LLMs must parse unstructured text to extract structured data (node IDs, wire counts, error details), increasing hallucination risk and token waste. Responses should return JSON objects with typed fields.
Inferred effective spec: <=2025-11-25.
| Scored | Grade | Overall | Spec posture | Rubric |
|---|---|---|---|---|
| 2026-09-23 | C | 63 | <=2025-11-25 | v2 |
Start an empty workflow draft, discarding the current one (coda_undo brings it back). A session starts with an empty draft, so this is only needed to start over.
One node type's full catalogue entry, with every param's help, followed by its documentation. Use it before configuring a node whose params are not obvious.
Step the draft back by one edit.
Parameter descriptions are minimal or absent. coda_get_link's 'include_json' and 'full_link' have 1-line descriptions; coda_apply_plan's 'plan' parameter is completely undocumented (schema delegated to external function). LLMs cannot determine when to use these parameters or what values are valid.
Error messages are generic and non-actionable. 'Refused, so nothing was applied' does not guide the LLM on recovery steps. Missing error classification (retryable vs user-fixable vs fatal) and no suggestions for alternative tools or corrective actions.