Skip to main content
Glama

Solve Capabilities

solve_capabilities
Read-only

Reports which external CFD, MBD, topology, thermal, and optics solvers are usable right now, so you can choose a working solver before submitting a job instead of testing availability.

Instructions

Report which P2 external solvers (CFD/MBD/topology/transient-thermal/optics) are usable right now — so you can pick a working solver for a *_submit family instead of discovering availability by trial and error. The solver twin of render_capabilities.

Takes no arguments. Resolves each solver side-effect-free: a binary by ANKUSDRIVE__PATH env -> PATH -> per-OS install dirs; a pip-wheel solver by importability. It executes nothing and installs nothing.

families[*].any_available is the gate to trust: it means AnkusDrive can actually DRIVE that family here, not just that a binary resolved. A solver that resolves but that no AnkusDrive tool can build a case for is listed under the family's prepared_case_only (with the reason on the solver entry) and does NOT set any_available — today that is SU2, which only ever runs a case_dir you prepared yourself (*.cfg + *.su2); every built-in CFD case mode is OpenFOAM-only.

Returns {platform, available (sorted ready solver names), unwired, prepared_case_only, solvers: {name: {available, kind ('binary'|'wheel'), family, extra, and either path/module (when available) or install_hint, plus prepared_case_only when nothing can build it a case}}, families: {family: {solvers, available, unwired, prepared_case_only, any_available}}, extras: {extra: [solver names]} for pip install ankusdrive[<extra>], toolsets: {enabled, disabled: {family: {label, tools, enable}}}, cases: {root, count, bytes, bytes_exact, keep, max_gb, grace_s, reaping}}. A family listed under toolsets.disabled has no tools registered in this session — tell the user its enable instruction rather than concluding the capability does not exist.

cases is where every generated solver deck is written (one managed root) and the retention it is held to: at most keep directories and max_gb GB, reaped oldest-first, never touching one younger than grace_s seconds. Point a user at cases.root when they ask where a solve's files went (issue #437).

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

Input Schema

NameRequiredDescriptionDefault
workspaceNoRun this call in this named workspace

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.4/5.0
Behavior4/5

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

Annotations already declare readOnlyHint=true and openWorldHint=false, but the description adds real content beyond that: it discloses the resolution order (env var -> PATH -> per-OS install dirs, or importability for wheels) and guarantees that no solver is executed and nothing is installed. The `any_available` vs `prepared_case_only` distinction is a genuinely non-obvious behavioral rule (a binary resolving does not mean AnkusDrive can drive it), with SU2 named as the concrete today-case.

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 the availability gate are front-loaded, and the later paragraphs on `toolsets.disabled` and `cases` retention each earn their place. The return-shape enumeration is dense and reads as a wall of nested braces, but it is load-bearing given there is no output schema.

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?

With no output schema, the description fully carries the return contract: top-level keys, per-solver fields, family gating semantics, extras/toolsets, and the case-retention policy (keep, max_gb, oldest-first reaping, grace_s). An agent has everything needed to call it and to interpret the result correctly.

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

Parameters3/5

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

Schema coverage is 100% and there is only one optional `workspace` parameter, so the schema carries the parameter burden and the baseline applies. However, the description asserts 'Takes no arguments,' which is mildly inaccurate against a schema that exposes a `workspace` routing parameter — an agent could miss that this call can be scoped to a named workspace.

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?

Opens with a specific verb+resource ('Report which P2 external solvers ... are usable right now') and enumerates the solver families in scope. It explicitly positions itself against a sibling ('The solver twin of render_capabilities'), so an agent can distinguish it from the many *_submit and *_check tools without opening a schema.

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

Usage Guidelines5/5

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

States the decision it enables ('pick a working solver for a *_submit family instead of discovering availability by trial and error'), which is exactly the when-to-use condition. It also gives explicit handling rules for two edge cases: families under `toolsets.disabled` should surface the `enable` instruction rather than be reported as nonexistent, and `cases.root` is the answer to 'where did my solve files go'.

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