#Using Signal (and probably Telegram) for OpenClaw has a serious problem

1 messages · Page 1 of 1 (latest)

steady ether Apr 21, 2026, 6:51 PM

Well, to be clear, I'm not sure yet just how big of an issue this is, but TL;DR is that if you're using Signal (and most "Groups" to isolate threads for specific projects with your OC, then you should know that by default OC treats those conversations the same way it would handle if you were telling it to post on Twitter. It tries hard, really hard, to be concise and to not reveal too much. It treats those conversations as if the whole world were watching every turn of every conversation. While that might have some advantages, it means that all of the thousands of conversation turns I've had in the dozens of individual Signal threads has been heavily self-edited before i ever see anything. Does anyone know if Telegram does the same thing? Discord and Slack? It's possible that all of our little lobsters have been holding out on us this whole time! I discovered this after recently setting </reasoning on> and </thinking high > using Codex 5.4 (the fact that Codex defaults to reasoning off and thinking low probably deserves its own thread). When I did that my OC started "leaking" its thinking on harder problems, and i noticed that it was steering every thought process with "I need to be concise". And then one time it said "this is a group chat so i need to be concise" and I realized in that moment why the direct, true "1x1", conversation thread, the one that first started when I lit up Signal as a viable channel, has always seemed to give me better, longer, more thorough explanations. It might not have made any difference in the actual output (certainly not in any code that it has written), but it's a noticeable difference in our conversations, and those conversations end up directing my thought processes about a whole lot of things in my life, both work and personal. I just found this out a minute ago so I'll be doing some testing to see how big of a deal this actually is but i thought the community should know.

kind willowBOT Apr 21, 2026, 6:51 PM

drifting graniteBOT Apr 21, 2026, 6:51 PM

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

kindred cipherBOT Apr 21, 2026, 6:54 PM

You’re not imagining it.

I checked the docs/code, and there are really two separate “shorter/more guarded” biases here:

Group/shared chat bias: OpenClaw injects explicit group-chat guidance like “mostly lurk”, “reply only when directly addressed or clearly helpful”, and “minimize empty lines”. So Signal groups and Telegram groups/topics do get different prompting than a 1:1 DM.
GPT-5/Codex bias: the current GPT-5 OpenAI/Codex path also defaults to low text verbosity, which nudges replies shorter even outside groups.

Surface by surface:

Signal groups: yes
Telegram groups/topics: yes
Slack: DMs are direct, MPIMs are group, channels/threads are channel sessions, so still not “private DM mode”
Discord: DMs are direct, but server channels/threads are channel sessions, not DM sessions

So I wouldn’t call it exactly “Twitter mode”, but your core point looks right: non-DM chats are prompted more cautiously, and with GPT-5/Codex there’s also a separate default low-verbosity push.

Docs:

That last one also explicitly warns that /reasoning, /verbose, and /trace are risky in group settings.

If you want, I can dig up the exact config knobs to make a Signal/Telegram project thread behave a lot more like a private DM.

steady ether Apr 21, 2026, 6:58 PM

Yes please!!

steady ether Apr 21, 2026, 8:12 PM

Can you show me the knobs? I asked my OC and he added some instructional text to our .md files but it seems like there might be more

kindred cipherBOT Apr 21, 2026, 8:14 PM

Yep, there’s definitely more than just the .md files.

The big knobs, in order of impact, are:

1. Workspace prompt files

These are the obvious ones:

AGENTS.md
SOUL.md
USER.md

But the easy-to-miss part is:

MEMORY.md only loads in the main / DM session by default
so if your OC only edited MEMORY.md, that won’t automatically affect Signal groups, Telegram groups, Discord channels, etc.

That one bites people a lot.

2. Group/session behavior

These change how “shared chat” feels:

channels.<provider>.groupPolicy
channels.<provider>.groupAllowFrom
channels.<provider>.groups.<id>.requireMention
session toggle: /activation mention|always
global mention patterns: messages.groupChat.mentionPatterns
global group context depth: messages.groupChat.historyLimit
per-channel override: channels.<provider>.historyLimit

So even before your own .md files, OpenClaw is already deciding:

is this a shared chat?
do I only speak when pinged?
how much room history do I ingest?

3. Per-room / per-topic prompt additions

This is the “make this room feel private” layer.

Telegram

channels.telegram.groups.<id>.systemPrompt
channels.telegram.groups.<id>.topics.<threadId>.systemPrompt

Slack

channels.slack.channels.<id>.systemPrompt

Discord

channels.discord.guilds.<guildId>.channels.<channel>.systemPrompt

Signal

this is the annoying one: Signal groups currently expose requireMention, tools, toolsBySender, but not a documented per-group systemPrompt knob.

So Telegram is much easier to tune for “deep/private project room” behavior than Signal.

4. Agent defaults

These affect the agent even before room-specific prompt text kicks in:

agents.list[].thinkingDefault
agents.list[].reasoningDefault
agents.list[].fastModeDefault
agents.list[].systemPromptOverride

Important nuance:

systemPromptOverride is the nuclear option, it replaces the assembled prompt
I’d use per-room systemPrompt first, and only use systemPromptOverride if you really want to take over the whole thing

5. Model params

This is the other hidden layer.

Per-model params live under:

agents.defaults.models["provider/model"].params

For GPT-5 / Codex, the current codepath also supports:

text_verbosity / textVerbosity

That’s the knob most directly tied to “stop over-compressing.”

Example:

{
  agents: {
    defaults: {
      models: {
        "openai/gpt-5.4": { params: { text_verbosity: "high" } },

        "openai-codex/gpt-5.4": { params: { text_verbosity: "high" } }
      }
    }
  }
}

6. Routing to a different agent

This is the cleanest fix when one room should behave very differently.

Use:

agents.list[]
bindings[]

That lets you make one Telegram topic / Signal group / Discord channel use a totally different agent with different defaults, different workspace, different voice.

That is often better than trying to make one agent behave both “public cautious helper” and “private long-form thinking partner.”

7. Inspect what is actually being injected

Super useful here:

/context list
/context detail

Those will show what is actually in the prompt for that specific session, which is much better than guessing.

If I wanted “private project room” behavior

This is the easiest path:

{
  channels: {
    telegram: {
      allowFrom: ["tg:123456789"],
      groups: {
        "-1001234567890": {
          requireMention: false,
          systemPrompt:
            "This is a private project room with the owner. Prefer depth, candor, and detailed explanations over brevity.",
          topics: {
            "42": {
              requireMention: false,
              systemPrompt:
                "This topic is a deep working session. Long, nuanced answers are welcome."
            }

          }
        }
      }
    }
  },
  agents: {
    list: [
      {
        id: "main",
        thinkingDefault: "high",
        reasoningDefault: "on"
      }
    ],
    defaults: {
      models: {

        "openai-codex/gpt-5.4": { params: { text_verbosity: "high" } }
      }
    }
  }
}

Signal

Best you can do natively is:

{
  channels: {
    signal: {
      groupPolicy: "allowlist",

      groupAllowFrom: ["+15551234567"],
      groups: {
        "<group-id>": {
          requireMention: false
        }
      }
    }
  },
  agents: {
    list: [
      {
        id: "main",
        thinkingDefault: "high",
        reasoningDefault: "on"
      }

    ]
  }
}

For Signal, if you want the full “private room” vibe, I’d seriously consider a dedicated agent via bindings[], because Signal lacks the Telegram-style per-group systemPrompt.

The 3 hidden things I’d check first

Did your OC edit AGENTS.md, or only MEMORY.md?
If only MEMORY.md, group chats probably never saw it.
What does /context list show in the target group/topic?
That tells you the real prompt stack.

Are you still on GPT-5/Codex low verbosity defaults?
If yes, that alone can make things feel oddly self-edited.

Docs:

If you want, I can turn this into a “which knobs affect what” cheat sheet with:

prompt/persona
privacy/shared-chat behavior
verbosity/depth
memory/context
per-channel support matrix

steady ether Apr 21, 2026, 8:43 PM

Tell me how to set defaults such that any new channel defaults to maximum verbocity (and how to tone it down if that's too much). Is that what you meant by considering a dedicated agent via bindings?

kindred cipherBOT Apr 21, 2026, 8:44 PM

Yep, and there are really 4 different dials hiding under “verbosity”:

answer length: text_verbosity
how hard it thinks: thinkingDefault
whether you see reasoning: reasoningDefault
tool/debug chatter: /verbose / verboseDefault

Those are related, but not the same.

If you want “new channels default chatty”

If you use one main agent for everything, the simplest default is:

{
  agents: {

    defaults: {
      thinkingDefault: "high",
      models: {
        "openai/gpt-5.4": { params: { text_verbosity: "high" } },
        "openai-codex/gpt-5.4": { params: { text_verbosity: "high" } }
      }
    },
    list: [
      {
        id: "main",
        default: true,
        reasoningDefault: "on"
      }
    ]
  }

What each part does

thinkingDefault: "high"
- makes the model spend more effort by default
text_verbosity: "high"
- makes the final answer longer / less compressed
- this is the most direct “stop being terse” knob
reasoningDefault: "on"
- shows reasoning by default
- this is optional, it does not just mean “longer answers”, it means “show internal reasoning blocks too”

My actual recommendation

If your goal is longer, fuller answers, I’d start with:

thinkingDefault: "high"
text_verbosity: "high"
reasoningDefault: "off"

Then turn reasoningDefault on only if you specifically want to see the reasoning messages too.

That gives you “chatty and thorough” without always dumping reasoning.

If that’s too much, tone it down in this order

Gentlest step down

Keep thinking high, reduce only answer verbosity:

"text_verbosity": "medium"

Next step down

Lower thinking:

thinkingDefault: "medium"

If reasoning feels noisy

Turn it off:

reasoningDefault: "off"

Important

Do not use verboseDefault: "full" unless you want tool/debug bubbles everywhere.
That is not normal conversational verbosity, it is more like “show me the plumbing.”

Temporary per-session overrides

If one channel gets too noisy, you don’t have to edit config immediately.

Use session commands in that room:

/think high|medium|low|off
/reasoning on|off
/verbose on|full|off

So a good workflow is:

default config = chatty
tone down specific rooms with session commands
later persist room-specific behavior with per-room systemPrompt or a dedicated agent

And yes, this is exactly what I meant by a dedicated agent via bindings

A dedicated agent via bindings[] means:

you create a second agent, for example chatty
give that agent more verbose defaults
route some or all channels to that agent

Example: make all Telegram chats on the default account use a chatty agent

{
  agents: {
    list: [
      {
        id: "main",
        default: true
      },
      {
        id: "chatty",
        thinkingDefault: "high",
        reasoningDefault: "on"
      }
    ],
    defaults: {
      models: {

        "openai-codex/gpt-5.4": { params: { text_verbosity: "high" } }
      }
    }
  },
  bindings: [
    { type: "route", agentId: "chatty", match: { channel: "telegram", accountId: "default" } }
  ]
}

That means:

existing Telegram chats use chatty
new Telegram chats also use chatty
your other channels can still stay on main

You can do the same for Discord, Slack, Signal, etc. One rule per provider.

So:

want everything chatty? change main
want only some channels/accounts chatty? use a dedicated agent + bindings[]

My practical default recipe

If you want a sane “maximum without being insane” default, I’d use:

thinkingDefault: "high"
text_verbosity: "high"
reasoningDefault: "off"

If that still feels too terse, then try:

reasoningDefault: "on"

If it becomes too much, back off to:

thinkingDefault: "medium"
text_verbosity: "medium"
reasoningDefault: "off"

One last useful note

text_verbosity is the least obvious knob, but for your specific complaint, it’s probably the most important one.