Flowmaps

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

Annotations already declare the safety profile (readOnlyHint=false, destructiveHint=false, openWorldHint=false). The description adds one genuinely new behavioral fact beyond that: fixed rules may flag legal, security, compliance, or cost risks. It does not say whether flags block creation or merely annotate the result, nor what the call returns, so the added context is real but thin.

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

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

Two short sentences with no filler. The core action is front-loaded and the secondary risk-flagging behavior follows, so nothing 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?

For a simple three-parameter create tool with a complete schema and annotations covering the safety profile, the description is close to sufficient. However, there is no output schema, and the mention of risk flags implies a return payload whose shape and effect on the caller remain unexplained.

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

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

Schema description coverage is 100%, so all three parameters (venture, title, notes) are already documented in the schema with constraints. The description adds no syntax, format, or naming guidance beyond that, so the baseline 3 applies.

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

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

The description gives a specific verb and resource: 'Adds a new idea card to a venture's mind map in Flowmaps.' The resource (idea card / mind map) is clearly distinct from every sibling, which deals with features, ventures, projects, or build instructions. It stops short of an explicit sibling comparison, so a 4 rather than a 5.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as start_feature or import_project. The agent must infer from the name alone that this is the tool for capturing a raw idea rather than creating a structured feature.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds genuinely useful context: the operation is a board state transition to 'Shipped' and should only fire after user validation and branch merge. It does not describe failure behavior if those preconditions are unmet.

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

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

Two tight sentences with zero filler. The core action is front-loaded and the precondition sentence immediately follows without 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-purpose state-transition tool with 100% schema coverage and annotations covering safety and idempotency, the description supplies everything an agent needs: what changes, when it is safe to call, and the gating preconditions.

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 both 'feature' and 'venture' are fully documented in the schema itself. The description adds no syntax or disambiguation guidance beyond that, so the baseline 3 applies.

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

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

States a specific verb-resource-state combination: 'Marks a feature Shipped on the user's board.' The target state 'Shipped' implicitly separates it from start_feature and list_features, though no sibling is named explicitly, which keeps it just shy of a 5.

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

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

Gives a concrete precondition for invocation: only after the user confirms the feature works and its branch is merged. This is clear when-to-use guidance, but it names no alternative (e.g. start_feature, list_features) or exclusion conditions, 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?

Annotations already declare readOnlyHint, destructiveHint false, and openWorldHint false, so the safety profile is covered. The description adds useful behavior beyond that: the result is a single document to follow in the current project and it also surfaces a git branch name, which tells the agent what it will get back.

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

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

Two short sentences, both front-loaded with the useful content (what it returns, then the secondary use case). No filler, though the second sentence's chat-app caveat is a bit tangential to invocation.

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 compensates by naming the returned artifacts (the build-prompt document and the branch name). Combined with annotations covering the safety profile and a fully documented two-parameter schema, little is missing for an agent to call 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% and both parameters (feature, venture) are documented in the schema itself, so the description is not required to carry parameter meaning. The description adds no syntax or format details beyond the schema, making the baseline 3 correct.

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 — retrieving the build prompts for a feature — and clarifies the resource with a parenthetical list (database, backend, frontend) plus the return of a git branch name. It does not explicitly contrast itself with siblings, but the resource is specific enough that an agent can distinguish it from list_features or start_feature.

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 gives one concrete usage context (a chat app without project access, to explain the plan) and labels the operation read-only, which implies when it is safe to call. However, it never says when NOT to use it or which sibling to prefer when the agent wants, e.g., to modify or start a feature, so usage is only implied.

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 cover only the basic write/non-open-world safety profile; the description adds materially more: it creates a persistent venture with side effects, requires filesystem access, is blocked in chat-app contexts, and is quota-bound (max 30 cards and only one venture on the Free plan). These are exactly the constraints an agent needs before committing to a write.

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

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

Front-loaded with a one-sentence outcome summary, then a numbered workflow and a closing paragraph of limits. Every sentence carries information, though the steps are verbose enough that a shorter imperative form would read faster. No filler or 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 4-required-param creation tool with no output schema, the description covers prerequisites, quotas, and expected input quality thoroughly. Its one gap is that it never says what the call returns (venture id/URL) or what happens if the one-venture limit is already hit, which an agent cannot infer from structured fields.

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, and the description goes beyond it by specifying semantic shape: 10-40 features total, plain-language user-facing phrasing, at most 5 self-added planned features (declared as such), and stack limited to one or two lines. It doesn't add per-field constraints the schema lacks, but it meaningfully guides how to populate them.

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 opening sentence states a specific verb and resource ('Turns the project you're working in into a new Flowmaps venture') and immediately enumerates the resulting artifacts: a mind map of features marked Shipped, plus the tech stack as a skill. No sibling tool does anything comparable, so an agent can distinguish it at a glance.

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 gives an explicit three-step pre-flight protocol (read the repo files, enumerate features with statuses, get user confirmation) and then states 'Only then call this tool.' It also names the alternatives for non-repo input ('If the user gave a GitHub address instead, clone it first') and the environmental precondition (won't work from a chat app).

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 and destructiveHint=false, so the safety profile is covered. The description adds a genuine behavioral constraint — that only Ready-to-build and In Progress features are returned, excluding other statuses — but says nothing about ordering, pagination, or result shape.

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

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

A single compact sentence with the status scope front-loaded and no filler. Appropriately sized for a simple list tool, though extremely terse.

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, single-optional-param list tool with full schema coverage and annotations carrying the safety profile, the description is sufficient to call it correctly. No output schema exists, but a list tool's return is self-evident.

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

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

Schema coverage is 100% with a single documented 'venture' parameter, so the schema does the heavy lifting. The description's 'optionally for one venture' usefully reinforces that filtering is optional, but adds no syntax or matching-behavior detail.

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) and resource (features), and scopes the result to two named statuses (Ready to build, In Progress). It is clear what the tool returns, though it does not explicitly distinguish itself from siblings like list_ventures or get_build_instructions.

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 status scope: an agent can infer this is the tool for viewing build-ready or in-progress work. But there is no explicit when-to-use guidance, no stated alternatives (e.g., how this differs from list_ventures), and no 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds genuinely new behavior: pinned ventures are surfaced first (result ordering), archived rows are omitted by default, and archived ventures are read-only. The 'they're read-only' clause partly restates readOnlyHint, keeping it out of the top band.

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

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

Three short sentences, zero filler, with the result shape (feature counts), ordering (pinned first), and filtering default front-loaded in that order. 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?

No output schema exists, so the description must carry return-shape burden, and it does reasonably: it discloses the per-venture feature counts and ordering. It does not mention pagination, total counts, or result-size limits, which is the one remaining gap for a list 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?

With 100% schema coverage and a single parameter, the baseline is 3, but the description adds real meaning beyond the schema's terse 'Also list archived ventures' — it explains the default (excluded), and that included archived ventures are read-only. That is decision-relevant context the schema does not carry.

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 ('The user's ventures (business ideas)') and even clarifies the domain term 'ventures' for an agent that might not know the product vocabulary. It also previews the payload's key attribute (feature readiness counts), which distinguishes it from feature-oriented siblings like list_features. It stops short of explicitly contrasting itself with any sibling.

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 tells the agent the default scope (archived excluded) and the condition that widens it (include_archived=true), which is clear usage context. It never says when to reach for this tool versus list_features or the other siblings, so guidance is implied rather than stated.

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

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

Annotations already declare readOnly=false, destructive=false, idempotent=true, openWorld=false. The description adds real value beyond those: the source and target board states, and the side effect that the board reflects git-following behavior. It omits what happens if the feature isn't in Ready state, which is the main remaining 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?

Three sentences, no filler, and the state transition — the most decision-relevant fact — is front-loaded before the calling restriction and parameter hint.

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

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

With no output schema and all three params documented in the schema, the description covers purpose, precondition, and the git_branch effect adequately. It could still say what error or no-op occurs when the feature is not Ready, given idempotentHint=true.

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 baseline is 3, but the description clarifies the effect of git_branch ('the board then shows the feature follows git') and frames 'feature' as one that is Ready, adding meaning beyond the schema's terse 'id.'

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

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

States a specific verb and resource with an explicit state transition: 'Moves a Ready feature to In Progress on the user's board.' An agent can separate this from finish_feature or list_features without opening any schema.

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

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

Gives a strong negative constraint: 'Only call this when you are actually building it now in the user's project.' Context and the capability precondition (you can edit their files) are clear, but it never names the counterpart tool (finish_feature) as the alternative for the opposite transition.

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