Skip to main content
Glama

reason

Read-onlyIdempotent

Prove goals against a knowledge base with multi-step deduction and return each solution's proof tree for verification.

Instructions

Prove a goal against a knowledge base and return every solution with its proof.

Use this for any question that needs multi-step deduction over facts and rules: transitive relations, permission inheritance, property inheritance, eligibility checks, or filtering a large fact set by a rule.

The goal comes from the query parameter, or from the ? ... line(s) in knowledge when query is omitted.

Returns ReasonResult:

  • ok (bool): false when the request could not be evaluated.

  • solutions (list): each has bindings (list of {var, value}, empty for a ground yes/no query), proof (a tree of {goal, type, children} where type is fact, rule or and), and proof_text (the tree rendered as indented text).

  • solution_count (int): how many solutions are returned.

  • truncated (bool): true when more solutions existed than max_solutions.

  • error (str | null): a readable, actionable message when ok is false.

An empty solutions list with ok: true means the goal is false under closed-world semantics - the knowledge base does not entail it.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
paramsYes

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
okYesFalse when the request could not be evaluated.
errorNoReadable, actionable message when ok is False.
solutionsNo
truncatedNoTrue when more solutions existed than `max_solutions`.
solution_countNoNumber of solutions returned.
Behavior5/5

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

The description discloses detailed behavioral traits beyond the annotations (readOnlyHint, idempotentHint, etc.): it explains the return structure (ReasonResult with ok, solutions, proof, etc.), closed-world semantics (empty solutions with ok:true means false), query source (from parameter or knowledge lines), and truncation behavior. No contradiction with annotations.

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

Conciseness5/5

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

The description is well-structured: a one-sentence core purpose, followed by usage scenarios, parameter interaction note, and a thorough yet concise breakdown of the return type. Every sentence is substantive, with no redundancy. The most critical information is front-loaded.

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

Completeness5/5

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

Given the tool's complexity (deduction with proofs) and the presence of a detailed output schema, the description provides sufficient context: it explains the return fields, error handling, truncated results, and the meaning of empty solutions. It does not repeat schema content but adds essential usage context. Output schema exists, so return value details are adequately covered.

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?

The input schema already has detailed descriptions for each parameter. The description adds value by explaining the relationship between query and knowledge parameters ('The goal comes from the query parameter, or from the ? ... line(s) in knowledge when query is omitted'), which is not present in the schema descriptions. This enriches parameter understanding.

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?

The description clearly states 'Prove a goal against a knowledge base and return every solution with its proof,' providing a specific verb+resource. It further lists example use cases (transitive relations, permission inheritance, etc.) and implicitly distinguishes from siblings like 'diagnose' and 'what_if' by emphasizing multi-step deduction.

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?

The description explicitly states 'Use this for any question that needs multi-step deduction over facts and rules,' giving clear positive guidance. However, it does not explicitly state when not to use it (e.g., 'do not use for simple fact lookups'), which would strengthen differentiation from siblings like 'check_kb'.

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

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/snegi26/euclidMCPPaper'

If you have feedback or need assistance with the MCP directory API, please join our Discord server