Skip to main content
Glama

environment_capture

DestructiveIdempotent

Captures remote engine and launcher bytes plus resolved shared libraries without running physics, returning a runtime ID for validation and repeatable change checks.

Instructions

Read remote installed engine/launcher bytes and resolved shared libraries; no engine invocation or physics. commands lists actual executables used by the native entry, e.g. ['lmp','mpirun'] or absolute paths. files lists extra absolute plugin/container/runtime dependencies. Returns an operation; use its runtime id in validation_plan. Repeating this capture measures changes without a new preflight job. Failures retain phase/exit_code in error.evidence; diagnose profile/module/file-reading failure from that receipt. Engine startup checks use accounted HPC.

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": {
      "task_id": "<task_id>",
      "revision": "<revision>",
      "commands": "<commands>",
      "op_id": "<op_id>"
    },
    "name": "environment_capture"
  }
}

Input Schema

NameRequiredDescriptionDefault
filesNo
op_idYes
tokenNo
task_idYes
commandsYes
revisionYes

Output Schema

NameRequiredDescriptionDefault
resultYes

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv1.0.0

TDQS

C2.9/5.0
Behavior2/5

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

The annotations declare destructiveHint=true and readOnlyHint=false, yet the description leads with 'Read ... bytes' and only describes non-mutating intent ('no engine invocation or physics'); an agent could easily read this as a safe inspection call. It does add genuinely useful behavior beyond the annotations — failures retain phase/exit_code in error.evidence and are diagnosable from that receipt — but the destructive side effect itself is never disclosed.

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 important scope statement is front-loaded and every sentence is attempting to convey operational detail, so it is not padded. However, several sentences are dense run-ons and the trailing 'Engine startup checks use accounted HPC.' is cryptic enough that it costs attention without landing a clear instruction.

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 an output schema present, return shape need not be explained, and the description correctly focuses on failure evidence, id reuse in validation_plan, and re-capture semantics. Against six parameters at 0% schema coverage and a destructive annotation, though, the missing parameter documentation and the undisclosed destructive effect leave real gaps for an agent deciding whether it is safe to call.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must carry all parameter meaning. It does a good job on two of six: 'commands' (actual executables used by the native entry, with example forms) and 'files' (extra absolute plugin/container/runtime dependencies). The required task_id, revision, op_id, and the token are never mentioned, leaving the majority of the surface undocumented.

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 sentence gives a specific verb and resource set — reading installed engine/launcher bytes and resolved shared libraries — and explicitly bounds scope with 'no engine invocation or physics', which separates it from submission/execution tools like analysis_submit. It does not name its closest sibling, environment_verify, so the boundary between 'capture' and 'verify' is left to inference.

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

Usage Guidelines3/5

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

It implies workflow context — the returned runtime id is consumed by validation_plan, and repeating the capture measures drift without a new preflight job — which tells an agent where this sits in a sequence. But there is no explicit when-to-use-this-vs-environment_verify guidance, and the closing line about 'accounted HPC' for engine startup checks is too terse to route the agent anywhere.

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