Skip to main content
Glama

Ask your Gambit agent

ask_gambit_agent

Talk to YOUR Gambit trading agent (the API key's user — requires the api:chat scope, 403 without it): market takes, analysis of your positions and recommendations, strategy discussion. Advisory only — this channel cannot execute trades or move funds. Each turn is a real agent run: it consumes your AI token quota (or runs on the user's own LLM key when they saved one in Settings) and can take 1-2 minutes, so don't call it speculatively. A done result carries data.llm (provider, model, key_source user or gambit), data.used_fallback, data.fallback_reason and data.notice: used_fallback true means the user's own key failed (fallback_reason: invalid_key, insufficient_credits, rate_limited, provider_error, model_unavailable, request_rejected) and Gambit's model answered instead — pass the notice on to the user. A reply that is ready within about 45 seconds comes back as data.status done with data.reply. A longer turn comes back as data.status running with data.conversation_id and data.asked_at: the turn keeps running and its reply is saved, so call get_conversation with wait_for_reply_after=asked_at, which returns the moment the reply lands, instead of asking again. The conversation persists server-side and continues across calls; pass new_conversation: true to start a fresh thread. To talk about one of YOUR Gambits, pass its case_id (from list_gambits): the turn goes to that Gambit's own conversation, the same thread the user sees on the Gambit in the app, and the agent answers with that Gambit in context (one thread per Gambit, so case_id cannot be combined with new_conversation). To show the agent a chart or screenshot, upload each image first (POST /api/chat/images with the raw image bytes and its Content-Type, api:chat; PNG, JPEG, WebP or GIF) and pass the returned url values as image_urls (up to 24). Read, rename or delete past conversations with list_conversations, get_conversation and manage_conversation.

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": {
      "message": "<message>"
    },
    "name": "ask_gambit_agent"
  }
}

Input Schema

NameRequiredDescriptionDefault
case_idNotalk about this Gambit in its own conversation; a Gambit id from list_gambits (UUID)
messageYes
image_urlsNourl values returned by POST /api/chat/images
new_conversationNostart a fresh conversation instead of continuing

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed1 schema field changed
    • addedInput schema / properties / case_id
      Added value: +{
      +  "description": "talk about this Gambit in its own conversation; a Gambit id from list_gambits (UUID)",
      +  "format": "uuid",
      +  "type": "string"
      +}
  2. Changed1 schema field changed
    • addedInput schema / properties / image_urls
      Added value: +{
      +  "description": "url values returned by POST /api/chat/images",
      +  "items": {
      +    "format": "uri",
      +    "maxLength": 512,
      +    "type": "string"
      +  },
      +  "maxItems": 24,
      +  "minItems": 1,
      +  "type": "array"
      +}
  3. First observed

TDQS

A4.9/5.0
Behavior5/5

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

Goes well beyond the annotations: discloses the scope requirement and 403 failure, that the channel is advisory-only and cannot execute trades or move funds, that turns burn AI token quota or the user's own LLM key, latency expectations, and the ~45s sync-vs-async cutoff. It also explains the fallback semantics (used_fallback, fallback_reason, notice to relay) and server-side conversation persistence, which the annotations cannot convey.

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?

Front-loaded with purpose, cost warning and the async handoff, so the most decision-critical facts come first. It is a dense single block, though — the enumeration of six fallback_reason values and the image upload mechanics could be tightened or split, which costs a point on structure rather than on wasted content.

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?

With no output schema, the description carries the full burden of describing returns and does so: data.llm (provider, model, key_source), used_fallback/fallback_reason/notice, and the two response shapes (status done with reply vs. status running with conversation_id and asked_at). Nothing an agent needs to call it, interpret the result, or continue the thread is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Adds real meaning on top of the 75%-covered schema: case_id is sourced from list_gambits, routes to that Gambit's own thread visible in the app, and cannot be combined with new_conversation (a mutual-exclusion rule absent from the schema). It also explains how to obtain image_urls (POST /api/chat/images with raw bytes and Content-Type, accepted formats) and that new_conversation starts a fresh thread rather than continuing.

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+resource ("Talk to YOUR Gambit trading agent") and immediately scopes the domain: market takes, position analysis, strategy discussion. It also disambiguates from the retrieval siblings by noting the conversation is read back via get_conversation rather than re-asking, so an agent can distinguish this from list_conversations/get_conversation without opening schemas.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicit when-to-use (market takes, position analysis, strategy discussion), when-not ("don't call it speculatively" because each turn is a real, 1-2 minute agent run consuming quota), and named alternatives with the exact condition that selects them (poll get_conversation with wait_for_reply_after=asked_at instead of asking again; use list_conversations/manage_conversation for past threads). Prerequisite (api:chat scope, 403 otherwise) is stated up front.

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

Try in Browser

Glama MCP Gateway

Add one secure layer between your agents and this server.

Resources