Skip to main content
Glama

Check this machine

environment
Idempotent

Inspects machine resources and solver backends, using an optional problem YAML to estimate run times per backend before starting a topology optimization job.

Instructions

Facts about this machine and the solver backends. Changes nothing.

Use it to answer "can this machine run it, and how fast?", or before a long run. Tell the user the numbers that matter. yaml_path: optional problem YAML (relative paths start at the work folder). With it, problem holds the time estimate for each backend (model values, not promises). Reply keys: resource topopt://replies/environment (the meaning of each key). If TOPOPT_PYTHON names another Python, the data is for that Python (run_interpreter says so). recommendations are offers as data: when a faster backend is possible but not installed (pypardiso on Linux x86_64, the Accelerate shim on a Mac), each has a reason, the command and license_note (speedup_factor when it is measured). This tool installs and builds nothing. If the user agrees, you run the command. Say the reason (and the speed-up) first. gpu_solver is a fact, not an offer. auto takes a GPU that passes a short self-test, and goes on with the CPU solver (auto_choice.cpu_solver) from the last checkpoint if gpu-mg fails during a run. settings.solver: gpu-mg asks for it on any OpenCL device (run_topopt has no solver argument: write it in the YAML) and has no fallback. The OpenCL device list and the self-test run in a child process (limit 60 s). At the limit opencl.problem says so, and auto takes the CPU rule; TOPOPT_AUTO_GPU=0 skips the wait. A gpu-mg run that stops with "did not reach the relative residual" lists its options in the error (settings.gpu_tol, settings.gpu_backward_error, settings.gpu_max_iter in case B, a stiffer start design, another solver); the residual history is in gpu_mg.jsonl of the run folder. gpu-mg takes springs, joints and per-axis supports (a fixed entry with axes), alone or together. In case C (no 64-bit float on the device) the joint term is computed in 32-bit float and the inner PCG removes the rigid modes of each body and 6 harmonic columns for each bonded patch, and solves them in 64-bit on the host: check prints the beam over the bond stiffness with the cases that were measured on pocl and on one Intel Arc iGPU (one host each; revision 133e5a1; a cube that only a joint holds solved at 9.9e-12 and above with the rigid modes removed, and at 3.3e-7 and above without; a part with two tube joints and no fixed region solved with the harmonic columns and stopped without them) and the memory of the columns, which the memory estimate does not count. These are facts, not a limit. A run that stops gives the ratio and the options (another solver, gpu_case B on a device with 64-bit float, a stiffer beam).

Input Schema

NameRequiredDescriptionDefault
yaml_pathNo

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.5.0

TDQS

B3.1/5.0
Behavior1/5

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

The description flatly asserts "Changes nothing" and "installs and builds nothing", while the annotations declare readOnlyHint=false. It also discloses that the OpenCL device list and self-test run in a child process with a 60 s limit, an action with real cost that the 'changes nothing' framing hides from an agent deciding whether to auto-approve. The rest of the disclosure (gpu-mg failure modes, case C behavior, env vars) is rich but does not cure this conflict.

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

Conciseness2/5

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

The first three lines are well front-loaded, but the remainder is a wall of deep solver internals — pocl and Intel Arc measurements, revision 133e5a1, residual values, harmonic columns, gpu_tol/gpu_backward_error tuning — that an agent does not need in order to call this tool or read its reply. Much of it reads as release notes rather than tool guidance.

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

Completeness3/5

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

With no output schema, the description does try to cover returns: reply key resource, the meaning of `recommendations` (reason, command, license_note, speedup_factor), and the distinction between a fact (`gpu_solver`) and an offer. But it never states the actual shape of the top-level reply or the units/format of the time estimates, and the bulk of the text is tangential to correct invocation.

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% and the single parameter is bare in the schema, so the description must carry it — and it does: yaml_path is optional, relative paths resolve from the work folder, and passing it changes the reply so `problem` holds per-backend time estimates. That is meaningful semantics beyond the schema.

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?

The opening line states a specific resource and scope: facts about this machine and the solver backends, with an explicit "Changes nothing" non-goal, reinforced by "Use it to answer 'can this machine run it, and how fast?'". It is clearly distinct from problem-oriented siblings such as check_problem/show_problem, though it never names them.

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 gives two concrete triggers (answering 'can this machine run it, and how fast?' and 'before a long run') plus a negative boundary ('installs and builds nothing ... if the user agrees, you run the command'), which is a real routing rule. It never names an alternative sibling for the case where the user wants a specific problem validated instead.

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