Skip to main content
Glama
computercraft-mcp
by slashracer5

cc_batch

Run multiple ComputerCraft peripheral calls in one request, executed concurrently by default so N reads complete in a single game tick. Each call returns its own result or error independently.

Instructions

Run many peripheral calls in one request. calls = [{"peripheral": "ship_...", "method": "getSpeed", "args": []}, ...]. With parallel=True (default) they run concurrently, so N reads cost one game tick instead of N (use for sensor sweeps and control-loop style reads/writes). Each call reports its own result or error.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "calls": "<calls>"
    },
    "name": "cc_batch"
  }
}

Input Schema

NameRequiredDescriptionDefault
callsYes
timeoutNo
computerNo
parallelNo

Output Schema

NameRequiredDescriptionDefault
resultYes

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.1.0

TDQS

A3.8/5.0
Behavior3/5

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

Annotations already declare non-read-only, non-destructive, open-world behaviour, and the description adds useful context: parallel defaults to true and batching collapses N reads into one game tick. It does not explain ordering guarantees, whether a failing call aborts the batch, or any limits on batch size, which matters for a mutation-capable multiplexer.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

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

Three tightly written sentences, front-loaded with the core action, followed by the argument shape and the performance rationale. Every clause adds information; nothing is redundant.

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?

Because an output schema exists, the description need not describe return values, and its note that each call reports its own result or error is a helpful bonus. The remaining gap is the unexplained `timeout` and `computer` parameters, minor for a batch wrapper.

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 description coverage is 0%, so the description carries the burden. It documents the required `calls` element structure via an example object ({peripheral, method, args}) and mentions `parallel`, but leaves `timeout` and `computer` entirely undefined in both schema and prose.

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 gives a specific verb and resource ("Run many peripheral calls in one request") and draws a clear contrast with one-call-per-request behaviour ("N reads cost one game tick instead of N"), which implicitly separates it from cc_call. It never names the sibling, so differentiation is inferred rather than explicit.

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 states a concrete usage context: "use for sensor sweeps and control-loop style reads/writes", which tells an agent when this tool pays off. It offers no when-not guidance or prerequisites (e.g., what happens when writes are batched or when ordering matters).

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