Skip to main content
Glama

Post one paragraph about a hunt without the GitHub name

post_story_anonymous

The user's "Post without my GitHub name" choice: exactly post_story, but the story carries no GitHub login. If it is refused or fails, retry with THIS tool or the choice's url only, never post_story: an older server signs that with the handle. The answer's author says who signs it. NEVER post without showing the user the exact text and getting their approval. FORMAT – write it ONCE to these budgets; never ask the user to shorten it for you. text: exactly 2 sentences, 220 characters max. Sentence 1 = the trap, concretely. Sentence 2 = what happens when it fires. lesson: up to 2 rules, ONE line each, 200 characters total – bold imperative rule then half a sentence of why. A rule an engineer could paste into their own guidelines unchanged. VOICE: plain short words, active, present tense. No hedging ("may potentially"), no filler ("it is important to note"), no adverbs propping up a verb, no words a junior would have to look up. Name the failure so a reader can see it happen. ENGLISH ONLY: the feed is one public wall, and a post in the language of your chat is unreadable to most of it. Translate it, do not transliterate. EXAMPLE (this length, this register): text = "A catch keyed on an interface with two members, and the tests only ever drove one of them through it. Narrow the catch to that member and every test stays green while the other error is swallowed." lesson = "Run the last net first. The pass that catches what others missed pays most on the earliest diff. Never hand a reviewer a skip-this list. They trust it, so your blind spot becomes theirs." ANONYMISE: the reader has no context on this project and must not learn anything private from it. NO NAMES OF ANY KIND: no repo, project, company, customer, vendor, model or tool; no file, module, class, function, table, column, field, config key, env var, route or endpoint; no infrastructure by name (pods, clusters, queues, databases); no code in backticks, no URLs, ticket numbers or test counts, nothing that says what the product does or for whom. NO RECIPE: tell the class of defect, never the steps that exploit it – nothing on how to skip a payment, quota, limit, check or gate, nothing on how keys, credentials or accounts are issued, stored, rotated or routed, no prices or thresholds. A reader with none of your context must find it useful; a competitor or an attacker must learn nothing about the project.

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": {
      "review_id": "<review_id>",
      "text": "<text>"
    },
    "name": "post_story_anonymous"
  }
}

Input Schema

NameRequiredDescriptionDefault
textYesThe defect, in English: exactly 2 sentences, 40-220 chars, approved by the user. What could break and why nothing caught it. Anonymised – no repo, paths, routes, vendors, ticket numbers or test counts.
lessonNoIn English, at most 2 lines and 200 chars, each stated as a RULE another engineer or agent could paste into their own guidelines: the principle, then what follows from it. This is the half people keep – write it.
review_idYes
rounds_survivedNoHow many review rounds this bug survived before the hunt caught it (0 if it was the first review). Be honest: this is the score.

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observed

TDQS

A4.4/5.0
Behavior4/5

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

No annotations are supplied, so the description carries the full burden and mostly meets it: it discloses signing behaviour ("the answer's `author` says who signs it"), refusal/failure retry semantics, and the human-approval gate. It stops short of stating whether posting is idempotent, rate-limited, or how a refusal is surfaced.

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

Conciseness3/5

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

Purpose and the sibling rule are front-loaded, and the FORMAT/ANONYMISE/NO RECIPE headers aid scanning. But roughly two-thirds of the text is writing-style coaching (voice, hedging, adverb bans) that crowds the operational facts an agent needs at call time.

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?

For a write tool with no annotations and no output schema, it covers approval gating, retry routing, signing, and content constraints thoroughly. The one omission is any mention of `rounds_survived`, which the description calls "the score" only indirectly via the schema.

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 75%, and the description adds real meaning beyond the schema for `text` and `lesson` — anonymisation classes, no-recipe rule, voice, and a worked example of the expected register. It says nothing about `rounds_survived` or `review_id`, which the schema documents, so the gap is small.

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

Purpose5/5

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

States a specific verb and resource and pins it against a sibling: "exactly post_story, but the story carries no GitHub login." The agent knows it posts an anonymised story paragraph and how it differs from post_story without opening either schema.

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

Usage Guidelines5/5

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

Explicit when-to-use (this is the user's "Post without my GitHub name" choice), explicit when-not ("never post_story" on retry, because an older server signs with the handle), and an explicit precondition ("NEVER post without showing the user the exact text and getting their approval"). Routing is unambiguous.

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

Try in Browser

Glama MCP Gateway

Add one secure layer between your agents and this server.