Skip to main content
Glama

Tolerance Cost Check

tolerance_cost_check
Read-only

Prices tolerance schemes against manufacturing process capability, flags dimensions needing secondary operations, and compares total cost indexes across alternative tolerance schemes.

Instructions

Price a tolerance scheme against the process that has to hold it — the missing link between tolerance_stackup ("what tolerance works") and cost_estimate ("what does it cost").

Per toleranced dimension: its ISO 286 IT grade as a FLOAT (a band between IT6 and IT7 reports 6.4, not 7), the cheapest machining operation that holds that grade naturally (drilling ~IT11, milling ~IT10, turning ~IT9, reaming ~IT7, grinding ~IT6), a relative cost index normalised to 1.0 at process's natural capability, and a verdict: 'ok', 'in_process_tightening' (tighter but reachable in the same operation), or 'needs_secondary_operation' — the flag, meaning the part silently acquired an operation nobody costed. pass is false when any link flags. Cost roughly doubles every 1.5 IT grades tightened below natural capability; above it only inspection/scrap falls. total_cost_index is the sum, so two tolerance SCHEMES over the same chain compare directly.

chain is the same [{name, nominal, plus, minus | tol}] tolerance_stackup takes; instead pass a live handle (+ axis, default_tol, general) and the chain is derived off the solid the same way. process: cnc | injection | casting | sheet | fdm | drilling | milling | turning | boring | reaming | grinding | honing | lapping.

fidelity='correlation', band_pct=50 — the RATIOS are defensible, the absolute index is dimensionless and is not money. Returns {process, links:[{name, nominal_mm, band_mm, it_grade, cost_index, verdict, cheapest_operation, natural_it, note}], n_links, total_cost_index, mean_cost_index, flagged, pass, fidelity, band_pct, basis, escalate_to}.

Tool call template

This tool declares no required parameters. Add optional parameters from the input schema as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {},
    "name": "tolerance_cost_check"
  }
}

Input Schema

NameRequiredDescriptionDefault
axisNo+z
chainNo
handleNo
generalNom
processNocnc
workspaceNoRun this call in this named workspace
default_tolNo

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed1 schema field changedv0.5.7
    • addedInput schema / properties / workspace
      Added value: +{
      +  "default": "",
      +  "description": "Run this call in this named workspace",
      +  "title": "Workspace",
      +  "type": "string"
      +}
  2. First observed

TDQS

A4.5/5.0
Behavior5/5

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

Annotations only declare readOnlyHint/openWorldHint; the description adds substantial behavior: cost roughly doubles per 1.5 IT grades tightened, above natural capability only inspection/scrap falls, the three verdict states including the 'part silently acquired an operation nobody costed' flag, that `pass` is false when any link flags, and that total_cost_index makes schemes comparable. It also discloses the fidelity caveat that the index is dimensionless and not money.

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?

Purpose and sibling positioning are front-loaded in the first sentence, and nearly every subsequent sentence carries real information (enum values, cost-doubling rule, return shape). The telegraphic dash-and-fragment style packs a lot in, though it borders on dense and the process list could be a single compact clause.

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 7-parameter tool with no output schema and 14% schema coverage, the description supplies the return object shape, the verdict vocabulary, the cost-scaling model, the fidelity caveat, and the escalate_to field, which is enough to call and interpret it. Residual gaps are the semantics of `axis`, `general`, and `default_tol` when deriving from a handle.

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?

With only 14% schema coverage this description carries the load: it gives the full `chain` element shape ({name, nominal, plus, minus | tol}), the handle-based alternative with `axis`/`default_tol`/`general`, and the complete `process` value set (cnc | injection | ... | lapping) that the schema leaves un-enumerated. It only lightly explains axis/default_tol/general and says nothing extra about `workspace`, so not quite a 5.

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 states a specific action ('price a tolerance scheme against the process that has to hold it') and explicitly positions the tool as the missing link between the named siblings tolerance_stackup and cost_estimate. An agent can tell exactly what this tool produces — per-link IT grade, cost index, and verdict — without opening the schema.

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?

It clearly says to run this after/alongside tolerance_stackup and cost_estimate, and explains the two mutually exclusive input modes: pass a literal `chain`, or pass a live `handle` (+ axis, default_tol, general) and let the chain be derived from the solid. It does not explicitly state when to prefer handle over chain beyond availability, but the routing is clear.

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

Deploy Server

Other Tools