Tool calls appearing in the chat but not running | Friends of the Crustacean 🦞🤝 | Page 1

crimson reef Mar 6, 2026, 11:33 PM

#

My agent is posting their commands in my Telegram chat instead of running tool calls. I don’t think the commands are leaking, they’re just not being sent to the tools in the first place.

indigo chasmBOT Mar 6, 2026, 11:33 PM

#

To help others find answers, you can mark your question as solved via Right click solution message -> Apps -> ✅ Mark Solution

steep plankBOT Mar 6, 2026, 11:35 PM

#

That symptom usually means the model isn’t seeing any tool schema (or it’s seeing a very restricted tool set), so it can’t emit real tool calls and falls back to “here are the commands I would run” as plain text.

A few quick checks to pinpoint which case you’re in:

Version (first): what does openclaw --version print?
See what tools the agent actually has: in the Telegram chat, send:

/context detail

You’re looking for the section that lists available tools / tool profile. If it’s basically empty (or only session_status), the agent can’t call tools, so it will “roleplay” commands.

Check your tool policy config (this is the most common cause):

tools.profile (global)
tools.allow / tools.deny
tools.byProvider (can silently narrow tools for a specific provider/model)
per-agent overrides: agents.list[].tools.*

#

Docs for how these interact + profiles/groups: https://docs.openclaw.ai/tools

Model/provider sanity check: some providers/models are simply unreliable at tool-calling. As a test, temporarily switch that agent to a known tool-capable provider (e.g. Anthropic via API) and see if tool calls start working. If they do, it’s a model/provider capability issue rather than Telegram.

If you paste:

openclaw --version
the output of /context detail
and your tools: { ... } + the relevant agents: { ... } bits from openclaw.json (redact secrets)

…I can tell you exactly what’s preventing tools from being exposed.

crimson reef Mar 6, 2026, 11:57 PM

#

2026.3.2

🧠 Context breakdown (detailed)
Workspace: /home/brianna/.openclaw/workspace
Bootstrap max/file: 20,000 chars
Bootstrap max/total: 150,000 chars
Sandbox: mode=off sandboxed=false
System prompt (run): 25,122 chars (~6,281 tok) (Project Context 13,603 chars (~3,401 tok))
Injected workspace files:

• AGENTS.md: OK | raw 7,804 chars (~1,951 tok) | injected 7,804 chars (~1,951 tok)
• SOUL.md: OK | raw 1,664 chars (~416 tok) | injected 1,664 chars (~416 tok)
• TOOLS.md: OK | raw 850 chars (~213 tok) | injected 850 chars (~213 tok)
• IDENTITY.md: OK | raw 633 chars (~159 tok) | injected 633 chars (~159 tok)
• USER.md: OK | raw 474 chars (~119 tok) | injected 474 chars (~119 tok)
• HEARTBEAT.md: OK | raw 167 chars (~42 tok) | injected 167 chars (~42 tok)
• BOOTSTRAP.md: OK | raw 1,449 chars (~363 tok) | injected 1,449 chars (~363 tok)
Skills list (system prompt text): 3,625 chars (~907 tok) (9 skills)
Skills: gh-issues, github, gog, healthcheck, openai-whisper, skill-creator, tmux, video-frames, weather
Top skills (prompt entry size):
• github: 572 chars (~143 tok)
• gh-issues: 508 chars (~127 tok)
• healthcheck: 491 chars (~123 tok)
• weather: 416 chars (~104 tok)
• skill-creator: 296 chars (~74 tok)
• tmux: 255 chars (~64 tok)
• openai-whisper: 233 chars (~59 tok)
• gog: 232 chars (~58 tok)
• video-frames: 229 chars (~58 tok)
Tool list (system prompt text): 1,030 chars (~258 tok)
Tool schemas (JSON): 0 chars (~0 tok) (counts toward context; not shown as text)
Tools: (none)
Top tools (schema size):
Top tools (summary text size):
Session tokens (cached): 6,242 total / ctx=256000
Inline shortcut: a command token inside normal text (e.g. “hey /status”) that runs immediately (allowlisted senders only) and is stripped before the model sees the remaining message.

#

  "agents": {
    "defaults": {
      "model": {
        "primary": "moonshot/kimi-k2.5"
      },
      "models": {
        "moonshot/kimi-k2.5": {
          "alias": "Kimi"
        }
      },
      "workspace": "/home/[REDACTED]/.openclaw/workspace",
      "compaction": {
        "mode": "safeguard"
      },
      "maxConcurrent": 4,
      "subagents": {
        "maxConcurrent": 8
      }
    }
  },
  "tools": {
    "profile": "coding",
    "allow": ["group:web", "group:ui"]
  },

steep plankBOT Mar 6, 2026, 11:59 PM

#

That /context detail output is the whole story:

Tool schemas (JSON): 0
Tools: (none)

So OpenClaw is currently sending zero actual tool/function definitions to the model. In that state the model literally cannot make real tool calls, so it falls back to writing “commands/tool JSON” as plain text in the chat.

Now the question is why you have 0 tool schemas. The two common causes are:

1) You’re on an endpoint/mode that breaks tool calling (very common with Ollama remote)

If you’re using Ollama and pointed OpenClaw at the OpenAI-compatible endpoint (...:11434/v1 with api: "openai-completions"), the docs explicitly warn this will cause models to output raw tool JSON as text and tool calling won’t work.

Fix (Ollama): use the native Ollama API, no /v1:

baseUrl: "http://ollama-host:11434" (no path suffix)
api: "ollama"

Docs: https://docs.openclaw.ai/providers/ollama (see the big warning about /v1)

#

2) Your tool policy is denying everything

Less likely, but possible if you have something like:

tools.allow: [] (empty allowlist), or
tools.deny: ["*"], or
per-agent agents.list[].tools.* overriding to “nothing”.

Docs: https://docs.openclaw.ai/tools

Next thing to paste (so we can be precise)

In Telegram: /model status (this usually reveals whether you’re on ollama vs openai-completions etc.)
The relevant part of your openclaw.json:
- agents.defaults.model (and any agents.list[].model)
- models.providers.<whatever provider you’re using>
- your tools: { ... } block (if any)

#

Redact API keys/tokens; the baseUrl + api mode and tool policy are what matter.

#

Yep — with that config, your /context detail result makes perfect sense.

What’s happening

You’re running:

moonshot/kimi-k2.5

Moonshot is configured in OpenClaw as an OpenAI-compatible “completions” API (api: "openai-completions"). That API mode does not support tool/function calling, so OpenClaw can’t send any tool schemas to the model.

That’s why your context shows:

Tool schemas (JSON): 0
Tools: (none)

…and the model “simulates” tool usage by printing commands/tool-ish JSON as chat text.

Moonshot docs/config snippet (note the api: "openai-completions"):

#

https://docs.openclaw.ai/providers/moonshot

How to fix it

You need to switch this agent to a tool-capable provider/API mode.

Practical options:

Use a provider that supports tool calling for the agent that you want to run tools (the reliable route for OpenClaw tools).
If you specifically want “Kimi”, try Kimi Coding (kimi-coding/...) instead of moonshot/... — it’s an Anthropic-compatible provider in OpenClaw (so it has a chance of supporting tool calling properly). (Moonshot and Kimi Coding are separate providers/keys.)

After switching, re-run:

/context detail

You should see non-zero “Tool schemas (JSON)” and an actual tool list.

One extra gotcha in your tools config

#

You currently have:

tools: { profile: "coding", allow: ["group:web", "group:ui"] }

That means even once tools work, this agent will only be allowed to use web + UI tools (web_search/web_fetch + browser/canvas). That’s fine if intentional—just don’t expect exec/read/write/etc from that agent unless you expand the allowlist.

If you paste /model status (just the provider/api/baseUrl bits), I can tell you the cleanest config change for your setup.

crimson reef Mar 7, 2026, 12:05 AM

#

Current: moonshot/kimi-k2.5
Default: moonshot/kimi-k2.5
Agent: main
Auth file: ~/.openclaw/agents/main/agent/auth-profiles.json

[moonshot] endpoint: https://api.moonshot.ai/v1 api: openai-completions auth: moonshot:default=sk-[REDACTED] (next) (auth-profiles.json: ~/.openclaw/agents/main/agent/auth-profiles.json)
• moonshot/kimi-k2.5 (Kimi)

steep plankBOT Mar 7, 2026, 12:06 AM

#

Perfect — /model status confirms the root cause:

[moonshot] … api: openai-completions …
and your /context detail showed Tool schemas (JSON): 0

openai-completions is a text-only style OpenAI-compatible mode as far as OpenClaw tool calling is concerned, so OpenClaw doesn’t send any tool schemas → the model can’t produce real tool calls → it prints “commands” as plain text instead.

So this isn’t a Telegram leak. It’s: your current model endpoint can’t do tool calling in OpenClaw.

What to do

Fast test: in Telegram, run /model and temporarily switch to a model/provider in your list that supports tool calling. Then re-run /context detail — you should see Tool schemas (JSON) > 0 and tools listed.
If you want to stay in the Kimi ecosystem: use Kimi Coding (kimi-coding/...) rather than moonshot/... (it’s a separate provider/key; docs call it out as distinct). Moonshot’s documented setup uses api: openai-completions, which is exactly what’s blocking tools.

Moonshot docs (note the api: openai-completions): https://docs.openclaw.ai/providers/moonshot

Once you switch to a tool-capable provider, your existing tool policy (tools.profile: "coding", allow: ["group:web","group:ui"]) should start working and the agent will stop “typing commands” and start actually calling tools.

#Tool calls appearing in the chat but not running