OpenClaw v2026.6.9: Smarter Telegram Delivery, Reliable Agent Recovery, and Deeper Codex Integration

Core question this section answers: What are the most impactful improvements in OpenClaw v2026.6.9, and why should you care?

This June 2026 release consolidates over 422 merged pull requests, touching everything from messaging channels and agent runtime to plugin architecture and mobile clients. Whether you interact with your agent via Telegram, rely on Codex for automation, or manage sessions from iOS or Android, this update brings noticeable stability gains and new capabilities.

Introduction: A Release That Listens to Real-World Pain Points

Open source releases often read like laundry lists of “what we changed.” OpenClaw v2026.6.9 feels different – it’s a concentrated response to actual user friction. From lost Markdown formatting in Telegram to agents freezing mid‑thought, and from SQLite corruption on network drives to session history glitches – the small frustrations that accumulate in daily use have been systematically addressed.

Reflection: What stands out to me is the sheer density of issue‑driven fixes. Many PRs reference specific GitHub issues, showing that the team isn’t just writing code – they’re actively listening to where users stumble. This “problem‑first” approach, rather than feature‑stacking, is a hallmark of a mature project.

1. Richer Telegram Interactions: More Than Just “Sending Messages”

Core question: What specific Telegram improvements land in this release, and how do they affect everyday use?

1.1 From Plain Text to Rich HTML Messages

Telegram now supports rich HTML‑formatted messages, not just raw text. When your agent replies, you can expect:

  • Bold, italics, code blocks, and other Markdown to render faithfully.
  • HTML tables to be displayed safely and cleanly.
  • Sticker paths to be preserved, so media context isn’t lost.

1.2 Real‑World Example: Visual Command Progress

Scenario: You send a long‑running command like npm run build via Telegram. Previously, you’d see a static “Executing…” message and wait minutes for a final result.

With v2026.6.9, Telegram now renders progress drafts – streaming the command’s live output into the chat. You watch each step – compiling, bundling, optimising – as if you were at a local terminal.

1.3 Technical Details: Mentions and Spooled Handlers

Bot mentions are now correctly bound to the agent’s identity, so the agent responds only when explicitly @mentioned. Meanwhile, spooled handlers (message queue processors) follow the right delivery path, preventing messages from being dropped in complex routing.

Takeaway: Telegram interaction evolves from “send and forget” to a native‑like experience, making remote agent operation far less opaque.

2. More Dependable Agent Recovery: Resuming Interrupted Conversations

Core question: How does the system automatically recover when an agent stalls or returns a partial reply?

2.1 Why Recovery Matters

AI agents are built on multi‑turn dialogues with tool calls. Anything can break:

  • Truncated API responses
  • Tool execution timeouts
  • Loss of context after compaction
  • Corrupted JSON streaming artifacts

Without recovery, you’re left with a frozen agent or missing replies – a deal‑breaker for productivity.

2.2 Key Recovery Enhancements

Issue Solution
Turns that contain only thinking (no output) Auto‑retry, rather than discard
Empty post‑tool final turns Retry to ensure a visible outcome
Lost usage stats after compaction Preserve “fresh” usage data through compaction
Partial JSON remnants in history Repair session history by dropping malformed fragments
Pending subagent announcements Retain unfinished subtasks during recovery

2.3 Real‑World Example: Seamless Continuation in Long Sessions

Scenario: You’re deep into a 50‑turn project planning session. The context window fills, triggering automatic compaction. In older versions, compaction might wipe out current token usage or tool call results, making the agent “forget” where you were.

Now, usage data survives compaction, so the agent continues with accurate cost and budget awareness. You barely notice the compaction – the conversation stays fluid.

Reflection: This is an invisible but crucial improvement. Many users complain that AI “gets dumber” over time – often because context and recovery aren’t robust. OpenClaw has invested heavily in this foundation, and that’s worth acknowledging.

3. Stronger Codex Integration: From “Call” to “Orchestrate”

Core question: What new Codex capabilities appear in this release, and how do they extend automation?

3.1 Auto Plugin Approvals and SecretRefs

Codex now supports automatic plugin approvals, reducing manual confirmations when running complex workflows. Additionally, SecretRefs allow Codex to securely reference encrypted keys – no more plaintext secrets in configuration.

3.2 Remote‑Node Execution (exec)

Most notably, when a remote node is connected, Codex exposes its exec capability as a dynamic tool. This means:

  • You can orchestrate tasks from one machine and execute commands on a remote node.
  • Results stream back in real time as part of the Codex workflow.

3.3 Real‑World Example: Distributed Builds and Deployments

Scenario: Your local laptop is fine for coding, but builds and deploys need to run on a powerful remote server. Previously, you’d SSH in manually, run commands, and switch back to check logs.

With remote‑node exec:

  1. You send a single instruction via Codex: “Run docker-compose up -d on the production server and confirm service status.”
  2. Codex detects that the remote node is online, routes the exec tool there.
  3. Results appear in your local chat – no terminal hopping needed.

3.4 More Robust App‑Server Lifecycle

Codex’s app‑server now tears down reliably after one‑shot runs, preventing leftover processes. Terminal outcomes are also ordered correctly, so you always see the final result, not fragments.

Takeaway: Codex evolves from “calling tools” to “orchestrating across nodes,” breaking the single‑machine barrier.

4. Plugin Ecosystem: Externalised Official Providers and Dynamic Loading

Core question: What structural plugin changes are introduced, and what do they mean for developers?

4.1 Official Providers as Standalone npm Packages

This is a architectural shift. Official provider modules (e.g., for connecting to various AI models or external services) are now published as independent npm packages. Benefits:

  • Install only what you need, not the entire plugin bundle.
  • Provider versions decouple from the core, enabling independent updates.
  • Third‑party contributors can publish their own providers more easily.

4.2 Gateway‑Time Discovery

When the OpenClaw Gateway starts, it automatically discovers and loads externally installed channel plugins – moving from compile‑time registration to runtime discovery.

4.3 StepFun Available from npm and ClawHub

StepFun, a popular step‑function plugin, can now be installed directly from npm or ClawHub, lowering the barrier for new users.

4.4 Real‑World Example: Custom Provider for Private Deployments

Scenario: Your team runs a self‑hosted LLM that follows the OpenAI API spec but isn’t the official OpenAI endpoint. Previously, you’d need to fork and modify OpenClaw core.

Now you can:

  1. Create a standalone npm package that implements the required provider interface.
  2. Publish it to your private npm registry.
  3. Specify that package in OpenClaw’s config – Gateway loads it at startup.
  4. No core code changes required.

Reflection: Externalising plugins is a pro‑ecosystem move. It lowers contribution friction and keeps the core lean. This “microkernel” approach often signals a project’s maturation.

5. Web and Mobile Clients: From “Functional” to “Delightful”

Core question: What user‑facing client improvements enhance daily management?

5.1 Control UI (Web)

  • Session workspace rail – quickly switch between and manage all active sessions without endless clicks.
  • Plugin health status – see at a glance which plugins are healthy, degraded, or failed.
  • Compact cron lists – cron jobs display in a denser format, saving screen space while retaining key info.

5.2 iOS

  • Watch app controls – trigger common actions directly from your Apple Watch.
  • Improved quick‑setup sheet layout – clearer groupings and navigation.

5.3 Android

  • Live chat context usage – token consumption and context window occupancy appear right in the chat view, helping you track costs and limits.

5.4 Real‑World Example: Managing Agents on the Move

Scenario: You’re commuting and want to check if yesterday’s cron job ran successfully. Previously, you’d need a laptop, browser, and Control UI.

Now:

  1. Glance at your Apple Watch – cron status notifications are pushed to the watch face.
  2. For more detail, pull out your iPhone and use the Watch‑triggered control panel to fetch logs.
  3. Even voice commands like “Hey Siri, ask OpenClaw for the latest task status” work (via iOS Shortcuts integration).

Takeaway: Client updates make agent management truly mobile – you’re no longer tied to a desktop.

6. Smarter Search and Skills

Core question: What search and skill management advancements appear, and how do they empower agents?

6.1 Codex Hosted Search

OpenClaw now includes Codex Hosted Search, allowing agents to retrieve external information on demand. This integrates deeply with Codex tool calls, acting as a “knowledge retrieval” step in workflows.

6.2 Key‑free Search Providers (Opt‑in)

Certain public search APIs can be used without an API key, but only if you explicitly opt in. This balances ease of use with privacy and security.

6.3 ClawHub Skill Provenance

Skills installed from ClawHub now retain verified source provenance – you can trace who published a skill and whether it’s been vetted, reducing the risk of installing malicious or low‑quality skills.

6.4 Real‑World Example: Agent Actively Searching for Updated Documentation

Scenario: You ask your agent to find recent API breaking changes for a popular library. In older versions, the agent would rely on training cutoffs and give outdated answers.

Now:

  1. Enable Codex Hosted Search in your config.
  2. Ask: “What breaking changes were introduced in the latest version of [library]?”
  3. The agent automatically triggers a search, retrieves official docs or community threads, and returns results with citations.

Reflection: Search capability is a pivotal step from “static knowledge” to “dynamic know‑how.” But the opt‑in design shows the team’s caution about privacy – not everyone wants their queries routed through third‑party search. Powerful but not forced – a principle worth adopting.

7. Key Fixes You Might Not Notice, But They Matter

Core question: Which fixes deserve special attention, and what problems do they solve?

7.1 Security and Privacy

  • Secrets are redacted from debug/config output – no more accidental API key leaks via debug show.
  • Internal HTTP session overrides are blocked – preventing malicious request hijacking.
  • Open‑DM tool exposure audited – ensuring direct‑message tools aren’t inadvertently exposed.
  • Plugin write ownership checks – only authorised plugins can write to the filesystem.

7.2 Storage and Migrations

  • SQLite WAL disabled on network filesystems – a practical lifesaver. Using NFS or SMB? WAL often leads to lock conflicts and corruption; now the system auto‑detects and falls back.
  • Reindex temp files cleaned – preventing disk space exhaustion.
  • Setup state moved out of workspace dot‑directories – keeping workspaces clean and version‑control friendly.

7.3 Channels and Replies

  • WhatsApp – keeps the opening text chunk even when media send fails, so you don’t lose context.
  • Mattermost – thread replies remain intact, fixing multi‑level reply loss.
  • Discord – action handling hardened to prevent freezes.

7.4 CLI and TUI

  • Global flags now work after subcommands – e.g., openclaw doctor --log-level debug parses correctly.
  • CJK IME composition – Chinese, Japanese, Korean input no longer jumps or garbles.
  • Terminal output and activity indicators stay visible during long‑running tasks.

7.5 Real‑World Example: Smooth Operation on Network Storage

Scenario: Your OpenClaw data directory lives on a NAS (NFS mount). Previously, SQLite WAL could cause random “database is locked” errors, especially with multiple Gateway instances.

Now, the system detects the network filesystem at startup and automatically reverts to non‑WAL mode – no config changes needed, errors disappear.

Takeaway: These fixes span security, storage, channels, and CLI, collectively hardening the system and building user trust.

Conclusion: The Long‑Term Value of v2026.6.9

OpenClaw v2026.6.9 isn’t a flashy “feature‑dump” release – it’s a pain‑driven polish of the entire platform. It introduces no radical new concepts, but instead stitches together every rough edge users encounter daily.

Architecturally, plugin externalisation, Hosted Search, and remote‑node exec open doors to more complex automation. In user experience, Telegram rich messages, agent recovery, and client refinements make everyday interactions smoother.

My verdict: If you’re an existing user, upgrade strongly recommended. If you’re evaluating OpenClaw, v2026.6.9 shows a mature framework – feature‑rich without bloat, transparent in its fixes, and backed by an active, process‑driven community.

Practical Summary / Action Checklist

  1. Telegram users – enable richMessages to enjoy formatted messages; set to false if you prefer plain text.
  2. Codex power users – review docs for Hosted Search and remote‑node exec to extend automation.
  3. Self‑hosted plugin developers – now publish official providers as independent npm packages; note Gateway’s dynamic loading.
  4. Network filesystem users – SQLite WAL handling is automatic; no manual steps needed.
  5. iOS users – update and set up Watch shortcuts for quick actions.
  6. Security‑sensitive environments – leverage improved secret redaction and session access controls; review your config.

One‑Page Summary

Area Core Change Impact
Telegram Rich HTML, progress drafts, format fidelity Clearer remote command feedback
Agent Recovery Retry empty turns, preserve usage after compaction Stable long conversations, fewer interruptions
Codex Auto plugin approvals, remote‑node exec Cross‑machine orchestration becomes real
Plugin Ecosystem Externalised official providers, dynamic loading Flexible installs and independent versioning
Clients Web rail, iOS Watch, Android context Manage agents from anywhere
Search & Skills Hosted Search, provenance tracking Real‑time knowledge, verifiable skills
Fixes Secret redaction, NFS SQLite, CJK IME Safer, more compatible, more localised

Frequently Asked Questions (FAQ)

Q: Is v2026.6.9 backward‑compatible with previous versions?
A: Yes – mostly fixes and improvements. Check the changelog for defaults that changed (e.g., richMessages now defaults to false).

Q: Do I need to change my Telegram config?
A: Only if you want rich HTML – set richMessages: true. Otherwise, plain text remains.

Q: Does Codex Hosted Search cost extra?
A: It depends on your OpenClaw subscription or self‑hosted setup. Check the official pricing docs.

Q: How do I install external provider plugins?
A: Via npm (e.g., @openclaw/provider-cohere) – Gateway auto‑discovers at startup. ClawHub is also available.

Q: Is the SQLite WAL issue on network drives fixed?
A: Yes – the system detects network filesystems and disables WAL to prevent lock conflicts.

Q: Can I reuse my old config with this release?
A: Mostly yes. Note that cron runMode now defaults to "due" instead of "force" – review your cron definitions.

Q: How can I verify a successful upgrade?
A: Run openclaw doctor and check the version. Also visit the Control UI status page for health indicators.