Skip to main content
Glama
Industrial-AIops Energy

Industrial-AIops Energy

verify_determinism

Read-only

Prove energy analyses are reproducible without a model: run a pinned reference suite twice, recheck in fresh interpreters, and compare SHA-256 digests to validate results.

Instructions

[READ][risk=low] Prove this engine's analysis is reproducible without a model.

Runs a named suite of analyses (availability, production counts, the Six Big
Losses, ISA-18.2 alarm load, control charts, the conservative baseline, the
RCA copilot) over a pinned reference dataset, canonically encodes each result
and digests it — twice in this process and, with ``subprocesses``, once more
in each of two fresh interpreters started at different PYTHONHASHSEED values.
That last arm is the one that catches a set or dict iteration order reaching a
result; a single run never can. The socket API raises throughout, so a
computation that reached for a device or a hostname fails here rather than
quietly succeeding on a machine that happens to be online. ``sys.modules`` is
checked afterwards for any model library — empty is the guarantee.

Use it to answer "how do I know your AI didn't make this number up": the
answer is that no model is in the path, and here is the SHA-256 that says so,
reproducible on the customer's own box. Read-only; nothing is written unless
the CLI (`iaiops verify determinism --out record.json`) is used to save the
signable record for a validation file.

Args:
    subprocesses: Also re-run in two fresh interpreters at fixed, different
        hash seeds (default True; adds roughly a second).

Returns dict: {check, result:{verdict ('reproducible'|'not_reproducible'),
    suite_digest, dataset:{name, revision, digest}, checks:[{name, covers,
    digest}], arms:[{arm, suite_digest, matches_first_arm}], arms_disagreeing,
    model_modules_loaded, network}, context:{iaiops_version, python, platform,
    generated_at, ...}, note}. ``result`` is identical between runs; ``context``
    is not — it records when and where this run happened.

Example: verify_determinism().

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": "verify_determinism"
  }
}

Input Schema

NameRequiredDescriptionDefault
subprocessesNo

Output Schema

NameRequiredDescriptionDefault

No arguments

Schema Changelog

Changes observed during successful MCP inspections.

  1. Addedv0.1.13

TDQS

A4.7/5.0
Behavior5/5

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

Beyond the annotations, it discloses subprocess execution, fixed differing PYTHONHASHSEED runs, socket API failures, the sys.modules model-libery check, and the fact that result is stable across runs while context is not. It also states the read-only caveat with the CLI --out path. 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.

Conciseness4/5

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

The description is front-loaded with purpose and risk, and each paragraph adds relevant behavior, parameters, or output shape. It is slightly verbose for a one-parameter tool, with the Returns dict and user-story framing adding length, but nothing is padding.

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?

For a single-parameter read-only verification tool, the description covers purpose, when to use it, execution model, side-effect caveat, return structure, and how to interpret reproducibility. Even with an output schema present, the inline Returns dict adds useful detail without leaving any gap needed to invoke the tool correctly.

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

Parameters5/5

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

Schema description coverage is 0%, and the Args section fully compensates by explaining that subprocesses re-runs in two fresh interpreters at fixed different hash seeds, defaults to true, and adds about a second. This is exactly the behavioral meaning the schema alone does not convey.

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 opening line states a specific verb and object: prove the engine's analysis is reproducible without a model. The next sentence enumerates the exact suite of analyses and the pinned reference dataset, and the socket/sys.modules constraints make it unmistakable among the many sibling health/read tools.

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 an explicit use case: answer 'how do I know your AI didn't make this number up', and clarifies the tool is read-only unless the CLI flag is added. It does not name alternatives or when-not-to-use conditions, so it misses the full when/when-not/alternatives bar.

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