OpenClaw Bug: Mattermost Markdown Breaks When replyToMode Is Set to "all"

A newly surfaced OpenClaw issue points to a frustrating but very concrete Mattermost regression: when replyToMode is configured as "all", Markdown formatting can disappear completely.

That means messages that should render as:

• bold
• italic
• lists
• inline code
• code fences

may arrive in Mattermost as plain text.

• Source issue: openclaw/openclaw#51755

TL;DR

If you run the Mattermost integration and set:

{
  "channels": {
    "mattermost": {
      "replyToMode": "all"
    }
  }
}

OpenClaw may strip or flatten Markdown formatting when it sends replies.

The current workaround from the report is simple:

• switch replyToMode from "all" to "off"

That appears to restore normal Markdown rendering.

What the bug looks like

According to the issue report, the problem is easy to reproduce:

1. Configure Mattermost with replyToMode: "all"
2. Send a message containing Markdown
3. Let OpenClaw reply
4. Observe that the rendered message loses formatting

Examples affected in the report include:

• bold text
• italic text
• list items
• code blocks

The bug was reported on:

• OpenClaw version: 2026.3.13
• Channel: Mattermost
• Mode: DM

Why this matters more than it seems

At first glance, this can sound cosmetic. It is not.

In operational chat workflows, Markdown carries structure. Losing it makes responses:

• harder to scan
• less trustworthy
• more error-prone when instructions contain steps or commands
• much worse for debugging output and incident notes

If your team uses Mattermost as a serious working surface, broken formatting is a usability regression, not a minor styling issue.

The key clue: direct Mattermost replies still work

One especially useful detail in the report: direct API calls to Mattermost using root_id preserve Markdown correctly.

That points the investigation away from Mattermost itself and toward OpenClaw’s own reply-handling path.

In other words:

• Mattermost seems able to render the Markdown
• the formatting is likely being altered inside OpenClaw when replyToMode: "all" is enabled

That makes this a good example of a bug caused by message-processing logic rather than by the downstream platform.

Likely blast radius

If the issue behaves exactly as reported, the users most likely to feel it are those who:

• use the Mattermost channel actively
• rely on threaded / reply-aware behavior
• keep replyToMode set to "all"
• send structured answers with lists or code

Users with replyToMode: "off" may never notice the issue.

Temporary workaround

Right now, the safest operational workaround is the one already given in the issue:

{
  "channels": {
    "mattermost": {
      "replyToMode": "off"
    }
  }
}

Then restart or reload your OpenClaw gateway as appropriate for your deployment.

This is not ideal if you depend on the reply behavior from "all", but it is the lowest-risk way to restore readable formatting immediately.

How to verify whether you are affected

Use a quick before/after test:

Test A — current config

1. Keep replyToMode: "all"
2. Send a prompt that forces structure, for example:
   • “Reply with a bold heading, a 3-item list, and a fenced code block.”
3. Check the actual Mattermost message rendering

Test B — workaround config

1. Change replyToMode to "off"
2. Restart / reload OpenClaw
3. Send the same prompt again
4. Compare rendering

If formatting returns only after switching to "off", you are likely hitting the same bug.

What upstream should probably fix

The issue description strongly suggests that the bug lives in the path OpenClaw uses when reply threading is enabled.

Practically, upstream should verify:

1. whether Markdown is being converted to plain text during reply processing
2. whether a reply wrapper is escaping or normalizing content incorrectly
3. whether the Mattermost transport path differs between replyToMode: "all" and replyToMode: "off"

This is worth testing with:

• bold / italic
• ordered and unordered lists
• inline code
• fenced code blocks
• blockquotes

because formatting regressions often affect these classes differently.

Recommended next steps for operators

If you run OpenClaw on Mattermost, the practical move is:

1. audit whether you use replyToMode: "all"
2. run a formatting test message
3. switch to "off" if formatting is broken
4. monitor the upstream issue for the permanent fix

If your deployment depends heavily on readable bot output, I would treat this as a real production issue, not a mere polish bug.

Fast operator checklist

If you need a low-drama incident response path, use this order:

1. confirm whether the broken output only happens when replies are threaded through replyToMode: "all"
2. capture one before/after screenshot or copy-paste sample for your internal incident note
3. change the Mattermost channel setting back to "off"
4. restart or reload the gateway
5. rerun the same Markdown test prompt
6. log the exact OpenClaw version and keep the upstream issue linked in your notes

That gives you a reversible workaround, a verification loop, and enough evidence to justify the config rollback.

Search-intent checklist

In real search traffic, operators usually do not search the full issue title.

They search symptoms such as:

• OpenClaw Mattermost markdown broken
• replyToMode all markdown lost
• Mattermost bot bold list code block not rendering
• OpenClaw Mattermost plain text instead of markdown
• replyToMode off fixes markdown Mattermost

If you landed here from one of those searches, use this short decision path:

1. If Markdown is broken only when replyToMode is "all"
   • you are very likely hitting the exact issue described here.
2. If Markdown is broken even when replyToMode is "off"
   • this is probably a broader Mattermost formatting or transport problem, not this specific bug shape.
3. If direct Mattermost API posts render correctly but OpenClaw replies do not
   • focus on OpenClaw's reply-processing path, not Mattermost itself.
4. If rolling back to "off" restores formatting immediately
   • treat this as confirmed enough for production mitigation while you wait for upstream.

That symptom-first framing is usually faster than starting from configuration theory.

When this article is probably NOT your problem

This article is likely the wrong match if:

• you are not using Mattermost at all
• formatting is broken in both standalone Mattermost posts and OpenClaw replies
• the issue is about message delivery, not rendering
• the failure started right after a custom proxy / formatter / plugin was added in front of Mattermost

In those cases, start with Mattermost rendering behavior, plugin interference, and transport customization before assuming you hit the replyToMode: "all" regression.

3-step operator summary

If you only have two minutes, do this in order:

1. test one Markdown-heavy reply with replyToMode: "all"
2. switch to "off" and rerun the exact same test
3. if formatting comes back, keep "off" in production and track the upstream fix

If step 2 changes nothing, this article is probably not your exact problem shape. If step 3 restores readability, rollback is justified immediately.

Who should not wait for an upstream fix

I would not wait if your bot output is used for any of these:

• on-call debugging
• deployment instructions
• incident summaries
• commands that teammates copy directly into a shell

In those cases, degraded formatting is an operational risk because it changes how people read and trust the output.

Source

• Issue report: openclaw/openclaw#51755