Skip to main content
Glama

send_message

DestructiveIdempotent

Queue a task for an OpenBot agent by ID or name and return immediately; the agent posts its tagged answer or failure back into the calling T3 thread, or another thread you choose.

Instructions

Queue work for an OpenBot agent, by ID or name, and return immediately. When it is done the agent posts its tagged answer, or its failure, into the calling T3 thread as a new message. Each send is self-contained: include the context the agent needs. Set report to false for fire-and-forget work.

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": {
      "agent": "<agent>",
      "text": "<text>",
      "requestId": "<requestId>"
    },
    "name": "send_message"
  }
}

Input Schema

NameRequiredDescriptionDefault
textYes
agentYesAgent ID or exact name from list_agents
reportNo
requestIdYes
reportToThreadIdNoAnother T3 thread to report to; the calling thread is the default

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.4.0

TDQS

A3.8/5.0
Behavior4/5

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

Beyond the annotations (readOnlyHint=false, destructiveHint=true, openWorldHint=true, idempotentHint=true), the description discloses the important behavioral facts: the call returns immediately, and the agent's tagged answer or failure arrives later as a new message in the calling T3 thread. That return-path contract is genuinely useful and is not in the schema. It does not explain why the operation is flagged destructive (agent/token consumption) or how requestId achieves idempotency, leaving some annotation-backed behavior unexplained.

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 sentences, each doing distinct work: the async contract first, then the reporting path, then the caller's context obligations and the fire-and-forget switch. No filler and no repetition of schema fields verbatim.

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?

For a five-parameter, non-idempotent-looking write with no output schema, the description covers the essentials: that nothing is returned synchronously and where the result surfaces instead. The remaining gap is requestId's deduplication role, which matters for a tool annotated idempotentHint=true and would help a caller reason about retries.

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?

With schema coverage at only 40%, the description must carry more weight, and it partially does: it clarifies that agent accepts an ID or exact name, that text must carry full self-contained context, that report=false means fire-and-forget, and that reportToThreadId defaults to the calling thread. The required requestId parameter receives no explanation in the description despite having a restrictive pattern, and the meaning of report=true (the default) is only implicit.

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 and resource: "Queue work for an OpenBot agent, by ID or name, and return immediately." The asynchronous, non-blocking nature is explicit, which an agent can act on without opening the schema. It does not, however, distinguish itself from siblings such as answer_prompt or list_pending, so the agent must infer the boundary.

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?

There is usable guidance in "Set report to false for fire-and-forget work" and "Each send is self-contained: include the context the agent needs," which tells the caller how to shape a call. But there is no explicit statement of when to prefer this tool over answer_prompt, list_pending, or run_routine, and no when-not guidance, so usage is only implied.

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