Skip to main content
Glama

record_execution

Logs significant tool call episodes by creating execution nodes, processing actual impacts, and storing objective signals for later reflection.

Instructions

Episodic log of a significant tool call. Creates an EXECUTION node + auto-observation, processes actual_impacts (lazy ARTIFACT creation + staleness), and stores objective_signals for reflect().

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
successYes
task_idYes
tool_nameYesCLI-aligned: bash, read_file, write_file, grep, git, etc.
unexpectedNo
budget_spentNo
input_summaryYes
actual_impactsNo
delegated_roleNo
return_summaryNo
delegated_modelNo
outcome_summaryYes
objective_signalsNoOptional environment-sourced signals. Recognised keys: tests_delta (int), lint_delta (int, negative = improvement), files_touched (int), predicted_files (int), impact_fidelity (float 0-1), retry_count (int), rollback_count (int). Unknown keys are ignored.
parent_execution_idNo

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.1.0

TDQS

B3.1/5.0
Behavior3/5

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

With no annotations, the description carries the behavioral disclosure burden. It discloses several effects: creating the EXECUTION node, auto-observation, lazy ARTIFACT creation, staleness processing, and storing objective_signals for reflect(). It does not mention side effects, persistence guarantees, failure behavior, or whether the operation is idempotent, so coverage is partial.

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 a single dense sentence with no filler. It front-loads the core purpose and packs related behaviors efficiently, though the parenthetical jargon may reduce readability for an unfamiliar agent.

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

Completeness2/5

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

Given the high parameter count, nested objects, absence of annotations, and no output schema, the description is too high-level to fully support correct invocation. It omits practical details about required field semantics, relationships among parameters, return behavior, and expectations for summaries or signals.

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 only 15%, so the description must compensate for the 13 parameters. It adds meaning for actual_impacts and objective_signals, but does not clarify required fields like task_id, input_summary, outcome_summary, success, or the delegated_* fields. This is a significant gap for a complex 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 description uses a specific verb and resource: it 'Creates an EXECUTION node + auto-observation' and logs a 'significant tool call.' This differentiates it from sibling record tools like record_fact and record_belief, though it does not explicitly name them.

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?

The phrase 'Episodic log of a significant tool call' gives an implied usage context: use this when recording a notable execution event. However, it provides no explicit when-to-use vs alternatives or exclusions, leaving this to inference.

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