Make OpenClaw Agent Less Verbose in Slack

If you've deployed an OpenClaw agent into a Slack workspace, you already know the feeling. You set it up, connect it, run a test task, and suddenly your channel looks like someone handed a megaphone to the most talkative person in the office. Every thought, every tool call, every intermediate observation — dumped straight into Slack like a stream-of-consciousness diary entry.

"I'm now going to search for that document..." "I found 47 results. Let me analyze them..." "Based on my analysis of the first 12 results, I believe..." "Let me reconsider my approach..." "Actually, I'll try a different search query..."

Meanwhile, your team is muting the channel and your actual important messages are buried under a wall of AI narration. You didn't want a play-by-play commentator. You wanted an agent that does its job and reports back with the answer.

This is probably the single most common complaint I hear from people running OpenClaw agents in Slack. The good news: it's completely fixable. The better news: once you understand the levers you can pull, you'll wonder why you ever ran it any other way.

Let's fix this.

Why Your Agent Won't Shut Up (It's Not a Bug)

First, it helps to understand why OpenClaw agents default to verbose output. It's actually an intentional design decision rooted in debugging.

When you're building and testing an agent, you want to see everything. You want to know which tools it's calling, what data it's receiving, how it's reasoning through a problem. Full visibility is essential during development. The problem is that most people deploy their agent to Slack without switching out of what is essentially debug mode.

OpenClaw agents have three main sources of verbosity:

1. Thinking narration — the agent explaining its reasoning steps out loud
2. Tool call announcements — broadcasting every API call, search, or function execution
3. Observation loops — the ReAct-style "Thought → Action → Observation" cycle being printed in full

In a development environment, all three are useful. In a Slack channel where your ops team is trying to get work done, all three are noise.

The Core Fix: Verbosity Configuration

The fastest way to quiet your agent down is the verbosity setting in your agent config. This is the single biggest lever, and it's the one most people miss.

from openclaw import Agent, Config

# This is probably what you're running now (default):
agent = Agent(
    config=Config(
        verbosity="full"  # Everything gets printed
    )
)

# What you actually want for Slack:
agent = Agent(
    config=Config(
        verbosity="results_only",  # Just the final output
        stream_thinking=False       # No intermediate reasoning
    )
)

Setting verbosity="results_only" tells the agent to do all its thinking internally and only surface the final result. The agent still reasons, still calls tools, still goes through its decision-making process — it just doesn't narrate the whole thing into your Slack channel.

The stream_thinking=False flag is the other critical piece. When streaming is enabled, the agent pushes each reasoning step to the output as it happens. That's useful for watching an agent work in real time during development. In production Slack? It's the primary source of the message flood.

Controlling Tool Call Announcements

Even with results_only mode, you might still see tool call notifications depending on your Slack integration setup. Here's how to clamp those down:

from openclaw import Agent, Config, SlackIntegration

agent = Agent(
    config=Config(
        verbosity="results_only",
        stream_thinking=False,
        show_tool_calls=False,      # Don't announce tool usage
        show_tool_results=False     # Don't show raw tool output
    ),
    integrations=[
        SlackIntegration(
            channel="#ops-alerts",
            message_format="final_only",  # Only post completed responses
            suppress_intermediate=True     # Kill all mid-process messages
        )
    ]
)

The show_tool_calls and show_tool_results flags are separate from the main verbosity setting because some teams actually want to see which tools the agent used without seeing the full reasoning chain. It's a middle ground: "Tell me you searched the knowledge base, but don't narrate your entire thought process about it."

For most Slack deployments, I recommend turning both off. If you need to audit what the agent did, use traces (more on that below).

The Middle Ground: Structured Summaries

Sometimes results_only is too aggressive. Maybe you're running an agent that handles multi-step workflows — researching, analyzing, drafting — and you want some visibility into progress without the full firehose.

OpenClaw has a summary verbosity mode that's perfect for this:

agent = Agent(
    config=Config(
        verbosity="summary",
        summary_format="bullet",  # Concise bullet-point updates
        summary_frequency="per_stage"  # One update per major step
    )
)

With this configuration, instead of getting 15 messages for a research task, you get something like:

✅ Searched knowledge base (12 results) ✅ Analyzed top 5 matches ✅ Generated summary

Result: Here's what I found about Q3 sales trends...

Three status lines plus the actual result. Your team can see the agent is working and what it did, without reading a novel about it.

Here's the comparison of what each mode looks like in practice:

Verbosity Mode	Messages per Task	Token Usage	Best For
full	10-20+	~2,500	Development/debugging
summary	3-5	~800	Team channels with oversight needs
results_only	1	~300	Production, automated workflows

The token savings alone are significant. If you're running an agent that handles 50 requests a day, switching from full to results_only can cut your token costs by 75-80%. That's not a rounding error — that's real money, especially at scale.

Fixing Multi-Agent Chatter

If you're running multi-agent setups in OpenClaw — say, a research agent handing off to a writing agent — the verbosity problem multiplies. Each agent narrates its work, and then they narrate at each other during handoffs.

The default multi-agent communication is chat-based, which means agents literally exchange pleasantries and confirmations:

Research Agent: "I've completed my research on the topic..."
Writer Agent: "Thank you, Research Agent. I'll now begin drafting..."

Nobody needs to see this in Slack. Switch to state-based communication:

from openclaw import MultiAgent

team = MultiAgent(
    agents=[researcher, writer, reviewer],
    communication="state_based",  # Structured data, not chat
    verbosity="minimal",
    slack_output="final_agent_only"  # Only the last agent posts to Slack
)

With communication="state_based", agents pass structured data between each other instead of having conversations. The researcher passes {"findings": [...], "sources": [...]} to the writer, not a paragraph explaining what it found. The work still gets done. Your Slack channel stays clean.

The slack_output="final_agent_only" setting ensures that only the last agent in the chain — the one producing the actual deliverable — posts to Slack. The intermediate agents do their work silently.

Don't Lose Visibility: Use Traces

The biggest pushback I get on reducing verbosity is: "But what if something goes wrong and I need to see what the agent did?"

Valid concern. Bad reason to keep the firehose on.

OpenClaw has a tracing system specifically for this. Think of it like structured logs that you can pull up on demand without polluting your Slack channels:

from openclaw import Agent, LogLevel

agent = Agent(
    config=Config(
        verbosity="results_only",  # Slack stays clean
    ),
    log_level=LogLevel.DEBUG,        # Full details saved to traces
    save_traces="./agent_traces/",   # Local trace storage
    trace_retention_days=30          # Keep 30 days of history
)

# After something goes wrong, pull the trace:
trace = agent.get_trace(session_id="abc123")
print(trace.tool_calls)      # Every tool call with inputs/outputs
print(trace.reasoning_steps)  # Full chain of thought
print(trace.token_usage)      # Token breakdown by step

This gives you the best of both worlds. Your Slack channel gets clean, concise outputs. Your debugging gets full visibility into every decision the agent made. The traces are structured and searchable, which honestly makes them more useful for debugging than scrolling through a wall of Slack messages anyway.

For production deployments, I also recommend setting up alerting so you're notified when something actually needs attention:

agent = Agent(
    config=Config(
        verbosity="results_only",
    ),
    log_level=LogLevel.INFO,
    alert_on_errors=True,
    error_channel="#agent-errors"  # Separate channel for failures
)

Errors go to a dedicated channel. Results go to the main channel. Noise goes nowhere.

Optimizing What Does Get Sent

Even in results_only mode, the actual results themselves can be unnecessarily verbose. OpenClaw agents sometimes include redundant context, overly detailed explanations, or raw data dumps when a summary would do.

You can control this with output filtering:

from openclaw import Agent, Config, OutputConfig

agent = Agent(
    config=Config(
        verbosity="results_only",
        output=OutputConfig(
            max_length=500,           # Cap response length (characters)
            format="concise",         # Prefer brevity
            include_sources=False,    # Don't list every source
            include_confidence=False  # Don't add "I'm 87% sure..."
        )
    )
)

The format="concise" setting is particularly useful. It instructs the agent's final response generation to prefer direct answers over explanatory ones. Instead of "Based on my analysis of the available data, I've determined that the sales figures for Q3 show an upward trend of approximately 15%, which suggests..." you get "Q3 sales are up 15%."

If you're using tool results that return large payloads — API responses, database query results, document contents — you can also filter at the tool level:

@tool(output_filter="relevant_only", max_output_tokens=200)
def search_knowledge_base(query: str):
    results = kb.search(query)
    return results  # OpenClaw extracts only what matters

The output_filter="relevant_only" decorator tells OpenClaw to semantically filter the tool's output before the agent processes it. Less data in means less verbose reasoning and shorter final outputs.

A Real Before-and-After

Let me show you what this looks like in practice. Say you have an agent that monitors your support queue and summarizes new tickets every hour.

Before (default verbosity):

🤖 I'm going to check the support queue now. 🔧 Calling: fetch_tickets(status="open", since="1h") 📊 I received 7 new tickets. Let me analyze them. 🤔 Ticket #4521 is about a billing issue. The customer reports... 🤔 Ticket #4522 is about a login problem. It seems that... [... 5 more detailed ticket analyses ...] 🤔 Now let me categorize these tickets... 📋 I've identified 3 billing issues, 2 login problems, 1 feature request, and 1 bug report. 📝 Let me now write a summary... Here's your hourly support queue summary: In the last hour, we received 7 new tickets...

After (optimized configuration):

Hourly Support Summary (7 new tickets) • Billing: 3 tickets (2 high priority) • Login: 2 tickets • Bug: 1 ticket (P1 — payment processing) • Feature request: 1 ticket

⚠️ P1 bug in payment processing needs immediate attention.

Same agent, same capabilities, same analysis happening under the hood. The difference is entirely in what gets surfaced to Slack. The second version is actually more useful because the signal isn't buried in noise.

The Fastest Way to Get This Right

If you're reading this and thinking "I just want this to work without spending an afternoon tweaking config settings," I get it. Honestly, the configuration isn't hard once you understand it, but there are a lot of little settings that interact with each other, and getting the balance right between useful updates and noise takes some iteration.

If you don't want to set this all up manually, Felix's OpenClaw Starter Pack on Claw Mart includes pre-built skills with sensible verbosity defaults already configured. It's $29 and comes with pre-configured Slack integration settings that solve exactly the problems I've described here — results_only mode, proper trace logging, output filtering, the works. Felix clearly built it after dealing with the same verbose-agent headaches because the defaults are exactly what I'd set up manually. It's a solid shortcut if you want to skip the trial-and-error phase and get straight to a clean Slack experience.

Quick Reference: My Recommended Settings

For most teams running OpenClaw agents in Slack, here's the configuration I recommend starting with:

from openclaw import Agent, Config, OutputConfig, SlackIntegration, LogLevel

agent = Agent(
    config=Config(
        verbosity="results_only",
        stream_thinking=False,
        show_tool_calls=False,
        show_tool_results=False,
        output=OutputConfig(
            format="concise",
            max_length=500,
            include_sources=False
        )
    ),
    integrations=[
        SlackIntegration(
            channel="#your-channel",
            message_format="final_only",
            suppress_intermediate=True
        )
    ],
    log_level=LogLevel.DEBUG,  # Full logging behind the scenes
    save_traces="./traces/",
    alert_on_errors=True
)

Start here, then adjust. If your team wants slightly more visibility, bump to verbosity="summary". If you need even less, cap the output length further or switch to a webhook that only fires on specific conditions.

What to Do Next

1. Audit your current setup. Check your agent config for verbosity settings. If you never set one, you're running on full — that's your problem.

2. Set results_only and stream_thinking=False. This alone will eliminate 80% of the noise.

3. Enable traces. Don't sacrifice debuggability for quiet. Log everything behind the scenes, keep your Slack channels clean.

4. Set up a separate error channel. Agent failures should go somewhere visible, but not in the same channel as routine outputs.

5. If you're running multi-agent workflows, switch to state_based communication immediately. The chatter between agents is the single biggest source of unnecessary Slack messages.

Your OpenClaw agent is powerful. It doesn't need to prove that by narrating every thought it has. Quiet competence beats loud busy-work — in people and in AI agents. Configure it once, and your Slack workspace goes from unbearable to actually useful.