Skip to main content
Glama

solve_heat_3d

Solve the 3D heat equation on a unit cube with explicit FTCS and constant Dirichlet boundaries, returning downsampled arrays and saving the full grid to .npz.

Instructions

Solve u_t = alpha*(u_xx + u_yy + u_zz) on the unit cube with explicit FTCS.

``nx``, ``ny``, ``nz`` are the number of intervals per axis (dx = 1/nx,
...) and ``nt`` the number of time steps. ``initial`` is an expression in
x, y and z; all six faces use the constant Dirichlet value ``boundary``.
The scheme requires r = alpha*dt/min(dx,dy,dz)^2 <= 1/6; larger values are
rejected as unstable. Grids above 500,000 cells are rejected. The full
(t, z, y, x) grid is saved to .npz; returned arrays are downsampled to at
most 20 points per dimension and 20 time points.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
ntYes
nxYes
nyYes
nzYes
alphaYes
t_endYes
initialYes
boundaryNo

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.1.0

TDQS

A4.4/5.0
Behavior5/5

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

With no annotations present, the description carries the full burden and delivers: it discloses the stability rejection rule (r <= 1/6), the hard cell-count limit (500,000 cells), and the output behavior (full grid saved to .npz, returned arrays downsampled to 20 points/dim and 20 time steps). These are non-obvious behavioral traits an agent cannot get from the schema.

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 governing equation is front-loaded, followed by parameter meaning, then constraints and return behavior in a logical order. It is dense but every clause is informative; a slight tightening of the return/limit lines would be the only improvement.

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 numerical PDE solver with no output schema and no annotations, the description supplies everything needed: the model, domain, method, parameter meaning, stability and size limits, and return format. Nothing essential for correct invocation is missing.

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%, so the description must explain all 8 parameters, and it explains most: nx/ny/nz as intervals per axis (with dx = 1/nx), nt as time steps, initial as an expression in x/y/z, and boundary as the constant Dirichlet value. alpha is conveyed implicitly via the equation and t_end is not explicitly defined, leaving minor gaps.

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 and the exact equation solved (u_t = alpha*(u_xx+u_yy+u_zz)) plus the domain (unit cube) and method (explicit FTCS). This unambiguously distinguishes it from siblings like solve_heat_1d, solve_laplace_3d, and solve_wave_3d.

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 communicates applicability constraints (unit cube, constant Dirichlet on all faces, stability bound r <= 1/6) which tells the agent when the call will succeed or be rejected. However, it never names an alternative solver (e.g. solve_heat_1d or solve_laplace_3d) or states when to prefer this over them, so usage is inferred rather than directed.

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