Loading ToolBench
MCP server for structured ideation — generating, scoring, deduplicating, and storing software ideas
Strong tool naming (verb_noun pattern throughout) and comprehensive descriptions. All 17 tools have clear, detailed descriptions (100-300+ chars) explaining WHAT, WHEN, and prerequisites. Input schemas are well-structured with types, descriptions, and constraints (enums, min/max). Output schemas are documented in descriptions. However, some tools lack explicit error handling guidance, and a few parameters could benefit from more granular type hints. Composition is excellent, tools chain logically (generate → save → score → critique → check_duplicate → promote). No security issues detected (no secrets in params). Pagination and result limits are implicit but not always explicit in schema.
Check if an idea duplicates any stored idea. This tool uses a TWO-STEP process: STEP 1: Call with only ideaId. The tool returns ALL stored idea summaries. Read each summary carefully. STEP 2: Compare the new idea against every stored idea. 'Too similar' means same core problem AND same solution approach (not just same domain or similar tags). Variations on a theme are ALLOWED — only reject near-identical ideas. Then call this tool again with ideaId, isDuplicate, and duplicateOf array. Call this AFTER critique_idea passes. Do NOT use this to browse ideas — use search_ideas instead.
Run adversarial critique on a single idea. You MUST argue AGAINST this idea — find every reason it should be rejected. Only truly strong ideas should survive. BEFORE calling this tool: 1) Use web search to look for existing products that solve the same problem — include URLs and product names in existingProducts. 2) Check if this is just a thin wrapper over an existing API. 3) Identify fragile dependencies. Rate the overall verdict: pass (strong idea survives scrutiny), weak (significant concerns but not fatal), or reject (fatal flaws found). Call this AFTER score_idea passes thresholds.
Decompose a complex idea into smaller, independent sub-ideas. Returns decomposition context and instructions for generating each sub-idea. After calling this, generate each sub-idea, then call save_idea with the parentId to record the lineage.
Permanently delete an idea and all associated data (scores, critiques, variants). Use with caution — this is irreversible. Only delete ideas that are clearly erroneous or duplicates.
Destructive tools (delete_idea, delete_rejection_pattern) lack explicit confirmation/dry-run pattern. No guidance on recovery or undo steps.
Error handling guidance is implicit in descriptions but not explicit in output schemas. Tools do not document error categories (retryable, user-fixable, fatal) or recovery paths.
Pagination not explicitly declared in search_ideas schema. No 'next_cursor' or 'total_count' documented in output, though limit parameter exists.
mutate_idea, refine_idea, decompose_idea return 'context and instructions' but output schema structure is not formally documented. LLM must infer response format.
| Scored | Grade | Overall | Spec posture | Rubric |
|---|---|---|---|---|
| 2026-09-23 | C | 62 | 2026-07-28+ | v2 |
Delete a stored rejection pattern. Use this to remove false positives — patterns that were learned from bad critiques and are blocking good ideas.
Generate a batch of 5-8 software idea candidates using distinct ideation techniques. Returns generation instructions for each candidate plus the full pipeline steps. After calling this, follow the pipeline: for each candidate, call save_idea (with full content + runId), then score_idea, critique_idea, and check_duplicate. Finally, promote top 1-2 scorers to shortlisted. Read the software-only constraints resource first.
Retrieve the full details of a single idea by UUID, including all fields, scores, critique, and status. Use this before planning mutations, refinements, or decompositions.
Mark an idea as re-validated after reviewing it. Updates the re_validated_at timestamp. Use this after calling resurface_idea and deciding to keep an old idea in the pipeline.
Create a new idea by mutating an existing one along a specified axis (e.g., 'target_user', 'problem_scope', 'business_model'). Returns the mutation context (parent idea details) and instructions for generating the variant. After calling this, generate the variant idea, then call save_idea with the parentId and mutationAxis to record the lineage.
Create an MVP action plan for a shortlisted or build-next idea. Breaks down the idea into concrete steps: research, design, build, test, launch. Returns a structured plan with effort estimates and dependencies. Call this AFTER promoting an idea to build-next.
Promote an idea from 'raw' to 'shortlisted' or from 'shortlisted' to 'build-next'. Only promote ideas that have passed scoring, critique, and duplicate checks. Shortlisted ideas are high-potential candidates; build-next ideas are ready for MVP planning.
Get refinement context for an idea and generate a refined variant. Refinement improves clarity, feasibility, or market fit without changing the core concept. Returns the refinement context and instructions. After calling this, generate the refined variant, then call save_idea with the parentId to record the lineage.
Reject an idea and move it to 'rejected' status. Provide a reason for rejection (e.g., 'failed critique', 'duplicate of X', 'below threshold'). Rejected ideas are hidden from the main pipeline but retained for historical analysis.
Find ideas that are candidates for re-validation. Returns ideas that were previously rejected or are stale (not updated in 30+ days). Use this to periodically review old ideas in light of new market conditions or improved techniques.
Save a new idea to the database. Call this IMMEDIATELY after generation, before scoring. Requires: title, one-liner, problem, solution. Optional: why_now, target_user, constraints, risks, domain, mvp_steps. Returns the saved idea with UUID. The runId links this idea to its generation batch for pipeline tracking.
Score a single idea on 7 dimensions (novelty, usefulness, feasibility, testability, speed-to-MVP, defensibility, clarity) and compute a weighted composite score. IMPORTANT: Before calling this tool, read the scoring-rubric resource (idea-lab://rubric) to calibrate your scores using the anchor definitions. Each score must be 0-10. Provide 1-2 sentence reasoning per dimension explaining your score relative to the rubric anchors. Call this AFTER generation, BEFORE critique. Do NOT score in the same context as generation — use a fresh tool call.
Search stored ideas by title, problem, solution, domain, or status. Returns matching ideas with title, one-liner, status, composite score, and domain. Use this to find specific ideas before planning mutations, refinements, or decompositions.
check_duplicate uses a two-step process (Step 1: fetch all, Step 2: compare) but this is not enforced by schema. LLM could skip Step 1 or call out of order.