Skip to main content
Glama
semlayer MCP server

semlayer MCP server

review_answer

Idempotent

Records a verdict on an open semantic-layer review question, immediately applying accept, reject, or set decisions and attributing who decided.

Instructions

Record a verdict. Takes effect immediately, and says who decided.

    key: the question's `key`, from `review_questions`.

    verdict: `accept`, `reject`, or `set:<value>` -- `review_question`
    gives the shape `set` takes.

    decided_by: `agent` if this is YOUR call, `person` if the user said
    it. Never guess this. You may accept a claim whose accept changes no
    behaviour; rejecting, setting, and accepting anything that unlocks
    behaviour are the person's, and you will be told which this is.

    by: the name to record. For a person, what they told you -- ask once
    if you do not know, never invent it, and never use your own client's
    name. For yourself, something recognisable like `claude-code/opus`.

    exclude: comma-separated object locations the verdict should skip.
    note: your reasoning, kept on the question whether or not the verdict
    was recorded. This is how you PROPOSE one you may not decide.

    If the layer is a set (a hub with members) this is refused and tells
    the user which terminal command records it, so do not promise them it
    is kept until you have the result.
    

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": {
      "key": "<key>",
      "verdict": "<verdict>",
      "decided_by": "<decided_by>"
    },
    "name": "review_answer"
  }
}

Input Schema

NameRequiredDescriptionDefault
byNoThe name to record: what the person told you, or something recognisable for yourself such as `claude-code/opus`.
keyYesThe `key` of the open question being decided, exactly as `review_questions` returned it.
noteNoYour reasoning, kept on the question whether or not the verdict was recorded.
excludeNoObject locations the verdict should skip, comma-separated: the `where` values from `review_question`.
verdictYes`accept`, `reject`, or `set:<value>`. `review_question` gives the shape `set` takes.
decided_byYes`agent` if the decision is yours, `person` if the user made it. Never guess.

Output Schema

NameRequiredDescriptionDefault
resultYes

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed6 schema fields changedv0.1.1
    • addedInput schema / properties / by / description
      Added value: +"The name to record: what the person told you, or something recognisable for yourself such as `claude-code/opus`."
    • addedInput schema / properties / decided_by / description
      Added value: +"`agent` if the decision is yours, `person` if the user made it. Never guess."
    • addedInput schema / properties / exclude / description
      Added value: +"Object locations the verdict should skip, comma-separated: the `where` values from `review_question`."
    • addedInput schema / properties / key / description
      Added value: +"The `key` of the open question being decided, exactly as `review_questions` returned it."
    • addedInput schema / properties / note / description
      Added value: +"Your reasoning, kept on the question whether or not the verdict was recorded."
    • addedInput schema / properties / verdict / description
      Added value: +"`accept`, `reject`, or `set:<value>`. `review_question` gives the shape `set` takes."
  2. First observedv0.1.0

TDQS

A4.1/5.0
Behavior5/5

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

Beyond the annotations (which only declare non-read-only, idempotent, non-destructive), the description discloses that the verdict applies immediately, that `note` is persisted even when the verdict is refused, that set-shaped layers are rejected with a terminal-command handoff, and that the agent should not promise persistence until it sees the result. That is exactly the extra behavioural context the annotations cannot carry.

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?

The operative fact (immediate effect, attribution) is front-loaded and the per-parameter blocks are scannable, but with 100% schema coverage the `key`, `verdict`, `exclude`, and `by` explanations largely restate field descriptions already in the schema. The prose is longer than the behavioural content requires.

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?

With an output schema available, return values need not be explained, and the description covers the mutation effect, attribution rules, refusal path, and note persistence. It leaves unstated what happens for an unknown or already-closed `key` and what an invalid `set:<value>` produces.

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 100%, so the baseline is 3, but the description adds policy meaning the schema does not: `decided_by` is framed as a never-guess field with decision-authority rules, `by` forbids using your own client name for a person, and `note` is recast as the mechanism for proposing a verdict you may not decide. `exclude` only restates the schema's comma-separated locations.

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?

"Record a verdict" names a specific verb and resource, and the added "Takes effect immediately, and says who decided" clarifies the mutation is live and that attribution is stored. It is clearly distinct from review_questions / review_question, which it cites as the source of `key`, though it never explicitly contrasts itself with review_decisions for reading back recorded verdicts.

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?

Strong conditional guidance: the agent may decide only accepts that change no behaviour, while rejects, sets, and behaviour-unlocking accepts belong to the person, with "you will be told which this is." It also names a when-not case (set layers are refused). It does not point to any sibling tool as an alternative path, which keeps it 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.