Skip to main content
Glama

job_request_screenshot

Requests a screenshot from a running job by flagging a pending capture; the runner uploads the image artifact and clears the request. Use it to verify visuals like HUD states or test results.

Instructions

Ask the runner for a screenshot: an info event plus params.pending_shot=true. The runner polls the job and answers by uploading an artifact, which clears the flag.

Input Schema

NameRequiredDescriptionDefault
noteNoWhat to capture, e.g. 'the HUD after the wall test'
job_idYesJob id from job_enqueue/job_list, e.g. 'j-1a2b3c4d'

Output Schema

NameRequiredDescriptionDefault
idYes
kindYes
linksNo
phaseNo
titleYes
eventsNo
originNoWho asked for this run (human | agent | driver | eval | probe | warmup) — scopes the learning loopagent
paramsNoIntake: purpose, expected, caps, flags, pending_shot, ...
statusYes
targetYes
workerNo
host_idNoNULL = not yet assigned (host_choice='ask')
summaryNoPresent once the job is closed out
web_urlNoAbsolute URL of this job's page in the web UI
positionNo
artifactsNo
created_atYes
project_idNo
started_atNo
updated_atYes
crash_countNocrash-level events (the queue board flags these)
error_countNoerror-level events (the queue board flags these)
finished_atNo
current_stepNoThe step awaiting a verdict (newest prompt event + whether it is answered)
requested_byNo

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.1.0

TDQS

A3.7/5.0
Behavior4/5

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

Annotations declare readOnlyHint=false, idempotentHint=false, destructiveHint=false, giving the safety/mutation profile. The description adds meaningful context beyond that: this sets a pending flag, the runner polls and answers asynchronously by uploading an artifact, and the flag clears. This discloses the async/non-immediate nature, which is valuable behavioral detail.

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?

Two sentences, front-loaded with the purpose followed by the mechanism. Dense but efficient; nearly every clause carries actionable information about the async flow.

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

Completeness4/5

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

Output schema exists and annotations cover safety, so the description carries less burden. It explains the async request/flag/artifact cycle well, but does not explicitly tell the agent how or where to retrieve the uploaded artifact afterward (e.g., via job_screenshots), a small gap for an async tool.

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%, so both job_id and note are already documented in the schema (including an example format). The description references `params.pending_shot=true` as part of the mechanism but adds no meaning to the actual input parameters beyond the schema. Baseline 3 applies.

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?

States a specific verb+resource: 'Ask the runner for a screenshot.' An agent understands this requests a new capture rather than listing existing ones. It does not explicitly distinguish itself from the sibling job_screenshots (which presumably lists captured screenshots), leaving that distinction 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?

Usage is implied through the mechanism description (info event + pending_shot flag), but there is no explicit when-to-use guidance and no routing to alternatives like job_screenshots for retrieving the result. The agent must infer the workflow context.

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