Skip to main content
Glama

park

Capture a side idea so you can resume current work without losing it. Preserves context for later pickup.

Instructions

Park an idea to come back to later — when the user says "park this", "remind me later", "let's come back to that", or mid-task surfaces a side idea not worth derailing for.

    ``text`` is the idea in one line; ``why`` the context needed to pick it up cold (what
    prompted it, what to check). Pass ``cwd`` (your working directory) so the item is scoped
    to that repo, or ``scope`` (``owner/repo``) directly; omit both for a global item.
    ``session`` optionally records the transcript it came from. Returns the stored item;
    ``similar`` lists open items that look alike (mention them — it may be a duplicate).
    

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "text": "<text>"
    },
    "name": "park"
  }
}

Input Schema

NameRequiredDescriptionDefault
cwdNo
whyNo
textYes
scopeNo
sessionNo

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.0.0

TDQS

A3.8/5.0
Behavior3/5

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

With no annotations, the description carries the full disclosure burden, and it does some of that work: the return value is stated ("returns the stored item") and a dedup signal is disclosed ("similar lists open items that look alike (mention them — it may be a duplicate)"). But persistence behavior, whether duplicate parks are allowed, and whether parking mutates any shared state are left unspecified — notable gaps for an unannotated write-ish tool, so it lands at 3 rather than 4.

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

Conciseness4/5

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

Front-loaded with purpose, then triggers, then parameter semantics — a sensible order with no filler sentences. It is dense but every clause carries information (scope resolution rules, the duplicate warning), so the length is earned; minor cost is that parameter prose is run together in one block rather than separated.

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

Completeness4/5

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

There is no output schema and no annotations, and the description still conveys the return shape and the notable 'similar' field, which is exactly what an agent needs. Missing lifecycle context — what happens to a parked item afterwards and which sibling resumes it — keeps this just below complete.

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

Parameters4/5

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

Schema coverage is 0%, so the description must compensate, and it largely does: text is "the idea in one line", why is "the context needed to pick it up cold (what prompted it, what to check)", cwd scopes to a repo, scope takes owner/repo, and session records the source transcript. The omission of both-scope/cwd behavior... it actually covers that ("omit both for a global item"), so this is close to 5; it loses a point only for not clarifying precedence if both cwd and scope are supplied.

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

Purpose4/5

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

Specific verb and resource: "Park an idea to come back to later" states precisely what is created. The trigger-phrase list makes the intent unambiguous, but it never distinguishes itself from sibling tools like list_parked, unpark, or resume_parked, so an agent still has to infer the retrieval side on its own.

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

Usage Guidelines4/5

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

Gives concrete when-to-use conditions via quoted user phrasings ("park this", "remind me later", "let's come back to that") plus the mid-task side-idea case, which is unusually actionable. It stops short of when-not guidance — no mention of when to prefer a learning/lesson tool or how to hand off to unpark — so it stays at 4 rather than 5.

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