DEV Community: cz

Qwen3.6-Plus: Alibaba's Quiet Giant in the AI Race Delivers a Million-Token Enterprise Powerhouse

cz — Thu, 02 Apr 2026 10:14:56 +0000

Qwen3.6-Plus: Alibaba's Quiet Giant in the AI Race Delivers a Million-Token Enterprise Powerhouse

🎯 TL;DR

Qwen3.6-Plus is Alibaba's latest flagship large language model, released April 2, 2026, designed specifically for enterprise agentic AI workloads
The model ships with a 1-million-token context window by default, enabling true repository-level code understanding and long-form task processing
Agentic coding is the headline capability of Qwen3.6-Plus — the model plans, executes, and refines tasks autonomously across complex engineering environments
Multimodal reasoning is built in, spanning text, code, images, and structured data across Alibaba's broader AI ecosystem (Wukong, Alibaba Cloud)
Available via API and integrated into Alibaba Cloud; early preview launched March 30, 2026, with free access on OpenRouter

What is Qwen3.6-Plus?
The 1-Million-Token Context Window: Why It Matters
Agentic Coding: The Real Headline
Multimodal Reasoning Across the Alibaba Ecosystem
Technical Architecture: Hybrid Design for Efficiency
Benchmark Performance
Enterprise Use Cases: Where Qwen3.6-Plus Shines
How to Access and Integrate Qwen3.6-Plus
Qwen3.6-Plus vs. The Competition
Frequently Asked Questions
Summary & Next Steps

1. What is Qwen3.6-Plus?

Qwen3.6-Plus is the latest iteration in Alibaba Cloud's flagship Qwen series of large language models. Released on April 2, 2026, Qwen3.6-Plus represents a significant step forward from its predecessors — not just in raw benchmark numbers, but in its fundamental design philosophy: agentic AI for real enterprise workflows.

While many AI labs have talked about "agentic AI" as a future aspiration, Alibaba has shipped Qwen3.6-Plus with agentic capabilities baked into its core architecture. The model doesn't just respond to prompts — it plans multi-step tasks, uses tools, refines its own approach, and operates across complex, repository-scale engineering environments.

The release also marks a quiet but meaningful shift in the global AI landscape. Qwen3.6-Plus positions Alibaba not as a follower in the LLM race, but as a contender with a differentiated focus on practical, deployment-ready enterprise AI. This isn't about beating GPT-5 on a single benchmark. It's about giving enterprises a model they can actually put to work.

2. The 1-Million-Token Context Window: Why It Matters

The most immediately striking spec of Qwen3.6-Plus is its 1-million-token context window by default. For those unfamiliar, this means the model can ingest and reason over approximately 750,000 words of text — or an entire large code repository — in a single context window.

To understand why this matters, consider the limitations of earlier models:

Model Generation	Typical Context	Practical Implication
GPT-3.5 era	4K–16K tokens	Single files, short documents
GPT-4 era	32K–128K tokens	Medium documents, small codebases
Qwen3.6-Plus	1,000,000 tokens	Entire repositories, years of documentation

A 1-million-token context transforms what's architecturally possible. A software engineering team can feed Qwen3.6-Plus an entire codebase — all dependencies, tests, documentation, and commit history — and ask it to reason about architectural decisions, identify bugs, or generate features that respect patterns established across hundreds of files.

This isn't extrapolation or "hope it works" context extension. Qwen3.6-Plus provides the 1-million-token window as a default, native capability — a direct response to the real-world need for repository-level AI assistance in enterprise environments.

3. Agentic Coding: The Real Headline

If the context window is the spec that gets attention, agentic coding is the capability that will determine whether Qwen3.6-Plus actually changes how enterprises build software.

Agentic coding goes beyond autocomplete or even code suggestion. Qwen3.6-Plus is designed to:

Plan a multi-file code change before writing a single line
Execute code changes across a repository with awareness of dependencies
Refine its own outputs based on test results, linting feedback, or human review
Reason about code architecture, identifying patterns and anti-patterns across large codebases
Debug with full repository context — tracing a bug to its root cause rather than patching symptoms

This is the difference between a basic AI and Qwen3.6-Plus, which acts as a true coding agent. Qwen3.6-Plus enables enterprises to automate entire workflows — from requirements to PR review — that previously required human senior engineers to orchestrate.

Alibaba has also deeply integrated Qwen3.6-Plus with its developer tooling ecosystem. The model is not just an API endpoint; it's designed to be embedded into IDEs, CI/CD pipelines, and code review workflows via Alibaba Cloud's developer services.

4. Multimodal Reasoning Across the Alibaba Ecosystem

Qwen3.6-Plus isn't a single-purpose coding model. It delivers multimodal reasoning — the ability to understand and generate across text, code, images, and structured data — and it's deeply integrated into Alibaba's broader AI ecosystem.

Qwen3.6-Plus connects with:

Wukong — Alibaba's multimodal foundation model for image understanding and generation
Alibaba Cloud — The enterprise cloud platform where Qwen3.6-Plus is deployed as a managed service
Qwen Chat — Alibaba's consumer-facing AI chat interface

This ecosystem integration means enterprises don't just get an LLM API — they get a cohesive AI infrastructure. A logistics company, for example, can use Qwen3.6-Plus to analyze warehouse images (via Wukong integration), process shipping documentation, optimize routing algorithms, and generate customer communication — all within a single, integrated workflow.

5. Technical Architecture: Hybrid Design for Efficiency

Alibaba's technical documentation describes Qwen3.6-Plus as built on a hybrid architecture designed for improved efficiency and scalability. While full architectural details remain closely held, this hybrid approach suggests a Mixture-of-Experts (MoE) inspired design — similar to how Qwen3-Coder-480B uses 480B total parameters with 35B active parameters per token.

This design philosophy reflects a pragmatic reality: enterprises need models like Qwen3.6-Plus that are powerful but not prohibitively expensive to run. Qwen3.6-Plus achieves this balance through its hybrid architecture. By activating only the necessary parameters for each task, Qwen3.6-Plus can deliver frontier-level performance at a fraction of the compute cost of dense models.

Qwen3.6-Plus also enforces chain-of-thought reasoning and tool use as core capabilities — not optional features toggled by prompt engineering. This means developers and enterprises get consistent, reliable reasoning traces without needing to craft complex system prompts.

6. Benchmark Performance

Across a broad set of industry benchmarks, Qwen3.6-Plus demonstrates strong performance, particularly in:

Agentic coding tasks — repository-level code understanding, multi-file code generation, automated debugging
Multimodal reasoning — image-text understanding, cross-modal consistency, document understanding
Long-context tasks — needle-in-a-haystack retrieval, multi-document synthesis, full-codebase analysis
Enterprise workflow tasks — business document reasoning, data analysis, multilingual processing (100+ languages supported)

While specific benchmark scores vary by test, the consistent theme from early evaluations of Qwen3.6-Plus is that it punches at or above the tier-1 frontier model level on agentic and coding tasks — precisely the workloads that matter most for enterprise AI deployment.

💡 Pro Tip
When evaluating Qwen3.6-Plus for your enterprise, focus on task-specific benchmarks relevant to your use case rather than aggregate leaderboard positions. The model's agentic coding capabilities may outperform its raw MMLU score suggests.

7. Enterprise Use Cases: Where Qwen3.6-Plus Shines

Software Engineering Automation

Qwen3.6-Plus is purpose-built for engineering teams. Qwen3.6-Plus empowers developers and enterprises alike with agentic capabilities. It can serve as an AI coding agent that:

Reviews pull requests with full repository context
Generates test suites covering edge cases across entire modules
Refactors legacy code while maintaining behavioral equivalence
Documents APIs and codebases automatically

Customer Service & Support

With Qwen3.6-Plus multimodal reasoning and 100+ language support, Qwen3.6-Plus powers multilingual customer service agents that understand text, images (screenshots, documents), and structured data — delivering coherent, context-aware responses across Alibaba Cloud's infrastructure.

Financial Analysis & Document Processing

Enterprises in finance and legal can leverage the 1-million-token context to analyze entire document repositories — years of filings, contracts, or research reports — in a single query, extracting insights and connections that would be impossible with shorter-context models.

Healthcare & Research

Qwen3.6-Plus multimodal capabilities combined with long-context processing enable Qwen3.6-Plus to synthesize research literature, analyze medical imaging reports alongside clinical notes, and support clinical decision-making with full patient history context.

8. How to Access and Integrate Qwen3.6-Plus

Qwen3.6-Plus is available through multiple channels:

Access Method	Details
Alibaba Cloud API	Managed endpoint via Alibaba Cloud ML Platform — production-ready
OpenRouter	Free preview access (as of March 30, 2026) — good for evaluation
Qwen Chat	Consumer interface at qwen.ai — quick experimentation
Hugging Face	Model weights available for self-hosting (Qwen3.5 series already on HF)

For enterprise integration, Alibaba Cloud provides:

REST API access with standard authentication
SDKs for Python, Java, and Node.js
Direct integration with Alibaba Cloud's data and compute services
SLA-backed production support

9. Qwen3.6-Plus vs. The Competition

How does Qwen3.6-Plus stack up against the leading frontier models?

Capability	Qwen3.6-Plus	GPT-4o	Claude 3.5 Sonnet
Context Window	1M tokens (native)	128K–1M (extended)	200K tokens
Agentic Coding	Built-in, core feature	Via extensions	Good, via extensions
Multimodal	Native, ecosystem-integrated	Native	Strong
Enterprise Integration	Alibaba Cloud-native	Via Azure OpenAI	Via Anthropic API
Multilingual (100+ languages)	Yes	Yes	Yes
Open Source Weights	Partial	No	No
Free Access	Yes (OpenRouter preview)	No	No

Qwen3.6-Plus's clearest differentiator is its default 1-million-token context combined with built-in agentic coding — both delivered as core capabilities rather than optional features or premium add-ons.

10. Frequently Asked Questions

Q: What is Qwen3.6-Plus?

A: Qwen3.6-Plus is Alibaba Cloud's latest flagship large language model, released April 2, 2026. It features a 1-million-token context window, built-in agentic coding capabilities, and multimodal reasoning, designed for enterprise AI deployment.

Q: How does Qwen3.6-Plus compare to GPT-4o?

A: Qwen3.6-Plus matches or exceeds GPT-4o on agentic coding and long-context tasks, particularly for enterprise use cases. Its Qwen3.6-Plus 1-million-token default context is larger than GPT-4o's standard offering, and its deep integration with Alibaba Cloud provides a compelling alternative for enterprises in Asia or with Alibaba ecosystem dependencies.

Q: Is Qwen3.6-Plus free to use?

A: Qwen3.6-Plus has a free preview on OpenRouter. For production enterprise use, Qwen3.6-Plus is available via Alibaba Cloud's paid API service with SLA guarantees.

Q: What makes Qwen3.6-Plus different from earlier Qwen models?

A: Qwen3.6-Plus is the first Qwen model to ship with agentic capabilities as a core, default feature rather than a prompt-based behavior. It also introduces the 1-million-token context as a native default (not extrapolation), and deeper ecosystem integration with Wukong and Alibaba Cloud services.

Q: Can I self-host Qwen3.6-Plus?

A: Model weights for the Qwen3.5 series are available on Hugging Face for self-hosting. Qwen3.6-Plus weights availability follows Alibaba's phased release model — check the official Qwen GitHub and Hugging Face pages for the latest.

11. Summary & Next Steps

Alibaba's release of Qwen3.6-Plus is a signal event in the enterprise AI race. While Western AI labs have dominated headlines, Alibaba has been quietly building an AI ecosystem that is now competitive at the frontier level — and more importantly, deployment-ready for real enterprise workflows.

The Qwen3.6-Plus 1-million-token context window, built-in agentic coding, and multimodal reasoning aren't just spec sheet wins. They're practical capabilities that enterprises can use today to automate complex, multi-step workflows across software engineering, customer service, financial analysis, and research.

If you're evaluating AI for enterprise deployment, Qwen3.6-Plus truly deserves serious consideration — especially if you're already in the Alibaba Cloud ecosystem or need best-in-class performance on agentic coding and long-context tasks.

Article generated based on publicly available information as of April 2026. For the latest model capabilities and pricing, visit Alibaba Cloud or Qwen.ai.

Originally published at: Qwen3.6-Plus: Alibaba's Quiet Giant in the AI Race Delivers a Million-Token Enterprise Powerhouse

CurateClick Weekly Picks: 6 Fresh Tools Worth Trying (Mar 22, 2026 Edition)

cz — Tue, 31 Mar 2026 04:48:04 +0000

TL;DR

CurateClick's latest Weekly Picks spotlight six tools that help you speak better, create faster, and express yourself more clearly—whether you're preparing for a dinner party, building an illustrated story world, or generating multi-shot cinematic video.

Dinner Party Practice — practice meaningful conversation with prompts + a wine-glass timer (plus optional speech analysis)
Pretty Scale — AI-based attractiveness analysis with breakdowns and privacy-first handling
C2story — create and evolve illustrated stories with reusable characters and 50+ art styles
Random Topic Generator — impromptu speech topics + built-in 1/3/5 minute timer
Seedance 2.0 — multimodal, controllable multi-shot AI video for cinematic storytelling
ValRequest — generate personalized romantic messages in different tones and lengths

What are Weekly Picks on CurateClick?

CurateClick is a discovery platform for useful products and tools. Weekly Picks are hand-selected highlights—things that feel unusually practical, surprisingly delightful, or simply ahead of the curve.

This roundup focuses on the most recent entries shown on the Weekly Picks page (latest date: Mar 22, 2026), and selects six products for deeper coverage.

1) Dinner Party Practice — the art of having something to say (Mar 22, 2026)

Best for: social confidence, language learners, networking, and anyone who wants to sound more interesting without sounding rehearsed.

Dinner Party Practice is a free, AI-powered "conversation gym." You pick a category (All Topics / Love / Culture / Personal), draw a card, then speak on a prompt while a wine-glass timer fills—an elegant little constraint that makes practice feel less like homework.

Why it stands out

Most "conversation starters" are shallow. Dinner Party Practice aims for questions that invite real stories and opinions—prompts that can turn a table of polite strangers into a room with momentum.

Notable features

Three thought-provoking prompts per draw
Wine-glass timer (1/3/5 minutes) to build fluency under gentle pressure
Optional AI speech analysis: transcript + rewrite + pacing + filler words + tone + pauses

A quick way to use it

Try a 3-minute session before any social event:

Draw a Culture or Personal card
Pick one prompt
Speak for 3 minutes
Review fillers and pacing once, then stop—don't over-optimize

🔗 Link: https://curateclick.com/product/dinner-party-practice

2) Pretty Scale — How Pretty Are You? Let AI Decide. (Mar 22, 2026)

Best for: curiosity, photo feedback loops, modeling/photography experimentation, or "just for fun" comparisons (with a reality check).

Pretty Scale is an AI-powered attractiveness evaluation tool that analyzes a photo and produces an overall score plus a dimensional breakdown. It offers two modes:

Scientific Evaluation (more objective framing + constructive feedback)
Roast Mode (same scoring, delivered with humor)

What's interesting (and what to be careful about)

The value here isn't "the number." It's the structured breakdown —symmetry, proportions, skin quality, facial structure, etc.—which can be used as a lens for photography, lighting, styling, and presentation.

At the same time, it's still a model. Treat results as feedback for iteration, not identity.

Privacy notes

Pretty Scale claims it doesn't store uploaded photos and deletes them after processing—exactly the kind of baseline hygiene you want for image analysis tools.

🔗 Link: https://curateclick.com/product/pretty-scale

3) C2story — Create Illustrated Stories with AI (Mar 7, 2026)

Best for: writers, educators, parents, indie comic makers, and anyone who wants to turn characters into a repeatable "story engine."

C2story is built around a simple but powerful idea: stories don't end after one generation. You create a character and a story—then continue, rewrite, or remix it into something bigger.

Why it stands out

A lot of AI storytelling tools generate a one-off output. C2story emphasizes:

Character persistence (reuse characters across stories)
Evolving narratives (branching and iteration)
Shared story worlds (collaboration and community remix)

Notable features

50+ visual styles (storybook, anime, watercolor, cinematic, cartoon, etc.)
Multi-language support (including bilingual editions)
Export options like PDF and downloadable asset bundles

Practical use cases

Teachers: create illustrated reading material tailored to a lesson
Families: personalized bedtime stories featuring your kid as the hero
Creators: prototype a comic series quickly, then refine the best arcs

🔗 Link: https://curateclick.com/product/c2story

4) Random Topic Generator — Impromptu Speech Topics & Timer (Feb 22, 2026)

Best for: Toastmasters, interviews, meetings, students, and anyone leveling up "thinking out loud."

Random Topic Generator does one job well: generate three impromptu speaking prompts, then let you practice with a built-in timer (1/3/5 minutes). It also supports English and Chinese, with optional hints like "technology" or "funny."

Why it's useful

Impromptu speaking is a foundational skill: interviews, standups, brainstorming, leadership moments. The hardest part is often starting —this tool removes the friction.

A simple training loop (10 minutes/day)

1 minute warm-up: one topic, speak without stopping
3 minutes: structure with PREP (Point, Reason, Example, Point)
5 minutes (optional): add a counter-argument or a personal story

💡 Consistency beats intensity here.

🔗 Link: https://curateclick.com/product/random-topic-generator

5) Seedance 2.0 — multi-shot cinematic video, no clips (Feb 10, 2026)

Best for: indie filmmakers, creative studios, content teams, and anyone trying to turn "AI video" from a toy into a workflow.

Seedance 2.0 positions itself as a multimodal AI video engine controlled by text, image, audio, and video —with the goal of producing production-ready, multi-shot cinematic stories in one go.

Why this matters

Most text-to-video tools struggle with three painful gaps:

Consistency (characters/scene drift across shots)
Narrative cohesion (clips don't feel like a sequence)
Audio-visual sync (lip sync and timing are fragile)

Seedance 2.0 claims progress on all three: director-like control, story pacing, and stronger audio alignment.

How to think about it

If you've ever storyboarded, you'll recognize the advantage of multi-shot generation: it's not just a pretty clip—it's a sequence with intent (camera, action, transitions).

Even if you don't ship the output directly, it can be a powerful:

previs tool (pre-visualization)
concept pitch generator
rapid iteration engine for narrative ads

🔗 Link: https://curateclick.com/product/seedance-2.0-create-multi-shot-movies-no-clips.-the-controllable-ai-video-generator

6) ValRequest — Turn Feelings Into Words (Feb 6, 2026)

Best for: people who care, but freeze when it's time to write; last-minute romantics; anyone who wants "sweet" without sounding generic.

ValRequest generates short, personalized romantic messages. You pick:

recipient type (partner / crush / friend)
style (heartfelt / humorous / Shakespeare / cute)
length (short / medium / long)
a few keywords that anchor the relationship

Then it returns three options—fast enough to be useful in real life.

Why it works

Good messages feel specific. The keyword input is a simple constraint that nudges outputs toward your actual story instead of Hallmark boilerplate.

Best practice

Use the AI output as a draft, then add one real detail:

a shared memory
a private joke
a near-future plan ("dinner Friday?")

💡 That single human detail upgrades the whole message.

🔗 Link: https://curateclick.com/product/valrequest

Want your product featured next?

CurateClick is built for discovery—but it only works if makers ship and share.

If you're building something useful (a tool, app, library, template, service, or weird little side project), submit it to CurateClick so more people can find it:

Submit here: https://curateclick.com/

The fastest way to grow is simple: make it easy for the right people to stumble into your work. CurateClick is one of those surfaces.

More Weekly Picks

Browse the full Weekly Picks archive here:

https://curateclick.com/weekly

Originally published at: CurateClick Weekly Picks: 6 Fresh Tools Worth Trying (Mar 22, 2026 Edition)

2026 Complete Guide: OpenClaw LCM Plugin — Never Lose a Single Conversation Again

cz — Mon, 30 Mar 2026 04:14:56 +0000

2026 Complete Guide: OpenClaw LCM Plugin — Never Lose a Single Conversation Again

🎯 Key Takeaways (TL;DR)

The Lossless-Claw plugin replaces OpenClaw's default context engine with a DAG-based storage system that never throws away conversation history
Every message is persisted to SQLite and summarized into expandable nodes — you can drill back into any point of your conversation
Setup takes under 5 minutes: install the plugin, flip one config flag, and you're running
Cost-conscious users can route summarization through a cheaper model (e.g., Claude Haiku) while keeping the main conversation on a premium model
This guide covers installation, configuration, architecture, agent tools, and troubleshooting — everything you need in one place

What Problem Does LCM Solve?
Installation Walkthrough
How the DAG Model Works
Configuration Deep Dive
Agent Tools: grep, describe, expand_query
Architecture Internals
Advantages Over Traditional Context Management
Known Limitations
Troubleshooting Common Issues
FAQ

What Problem Does LCM Solve?

By default, OpenClaw uses a legacy context engine that truncates or slides old messages out of the context window as conversations grow. Once those messages are gone, the agent loses access to earlier context entirely. This is a fundamental problem for long-running projects, complex debugging sessions, or any conversation that spans days or weeks.

The Lossless-Claw plugin replaces this with a fundamentally different approach:

Every message is persisted to a local SQLite database — nothing is ever deleted
Old messages are summarized into a DAG (Directed Acyclic Graph) of layered summaries
The agent can drill back into any summary to recover full details on demand
Context assembly is budget-aware, fitting the most relevant information into the model's context window

The result: conversations that can run for hundreds or thousands of turns without the agent "forgetting" what happened earlier.

Installation Walkthrough

From npm (Recommended)

openclaw plugins install @martian-engineering/Lossless-Claw

From a Local Clone (for Development)

git clone https://github.com/Martian-Engineering/Lossless-Claw.git
openclaw plugins install --link ./Lossless-Claw

Activate as the Context Engine

This step is required. Without it, the plugin loads but does not run — the default legacy engine remains active.

openclaw config set plugins.slots.contextEngine Lossless-Claw

Verify

openclaw plugins list

You should see Lossless-Claw listed as enabled, with the contextEngine slot assigned to it.

Update

openclaw plugins update @martian-engineering/Lossless-Claw
# Or update all plugins at once:
openclaw plugins update --all

How the DAG Model Works

The Core Insight

Traditional context management is linear: keep the latest N messages, discard the rest. LCM builds a tree instead:

Raw messages:   [m1] [m2] [m3] ... [m20] [m21] ... [m40] ... [m80] ... [m100]
                 ↓ chunk                  ↓ chunk            ↓ chunk
Leaf (d0):     [leaf_1: m1-m20]      [leaf_2: m21-m40]   [leaf_3: ...]  [leaf_4: ...]
                 ↓                        ↓
Condensed (d1): [cond_1: leaf_1 + leaf_2]                 [cond_2: leaf_3 + leaf_4]
                 ↓                                            ↓
Condensed (d2): [cond_3: cond_1 + cond_2]
                                                    ↑
                                            still expandable

Each node carries metadata: time range, token counts, descendant counts, and references to its sources. The agent sees summaries in the context window, and uses retrieval tools to drill into any node for full detail.

Lifecycle Hooks

The engine hooks into four points in OpenClaw's conversation flow:

Phase	What Happens
Bootstrap	On session startup, reconciles the JSONL session file with the SQLite database. Imports any messages that appeared since the last checkpoint.
Assemble	Before each model call, builds the message array within the token budget: recent raw messages (the "fresh tail") plus selected summaries from the DAG.
After Turn	After the model responds, persists new messages and evaluates whether compaction is needed.
Compact	When the context exceeds the threshold, runs leaf and/or condensed summarization passes to compress older content.

Compaction: Three Escalation Levels

Every summarization attempt follows a fallback chain to guarantee progress:

Normal — Full-fidelity prompt, temperature 0.2, target ~1200 tokens
Aggressive — Tighter prompt with fewer details, temperature 0.1, lower token target
Deterministic fallback — Truncates to ~512 tokens with a [Truncated for context management] marker

Even if the summarization model is down or returns garbage, compaction still succeeds.

Large File Handling

When a message contains a file (code paste, log dump, etc.) exceeding the largeFileTokenThreshold (default 25,000 tokens):

The file content is extracted and stored on disk (~/.openclaw/lcm-files/)
A ~200-token structural summary replaces the file in the message
The agent can retrieve the full file via lcm_describe

This prevents a single large paste from consuming the entire context window.

Configuration Deep Dive

Open your config with openclaw config edit and add settings under plugins.entries.Lossless-Claw.config:

{
  "plugins": {
    "slots": {
      "contextEngine": "Lossless-Claw"
    },
    "entries": {
      "Lossless-Claw": {
        "enabled": true,
        "config": {
          // All fields are optional — defaults are sensible
        }
      }
    }
  }
}

All settings can also be overridden via environment variables (prefix LCM_, e.g. LCM_FRESH_TAIL_COUNT=32). Environment variables take highest precedence.

Key Parameters

Parameter	Default	Description
`contextThreshold`	`0.75`	Fraction of the model's context window that triggers compaction. At 0.75, compaction fires when 75% of the budget is consumed.
`freshTailCount`	`20`	Number of most recent raw messages that are always included and never compacted. This is the agent's "working memory."
`incrementalMaxDepth`	`-1`	How deep incremental (per-turn) condensation goes. `0` = leaf passes only, `1` = one condensation level, `-1` = unlimited.
`dbPath`	`~/.openclaw/lcm.db`	Path to the SQLite database.
`summaryModel`	(session model)	Model override for summarization. Use a cheaper/faster model to reduce costs (e.g., `anthropic/claude-haiku-4-5`).
`expansionModel`	(session model)	Model override for the `lcm_expand_query` sub-agent.
`largeFileTokenThreshold`	`25000`	Files above this token count are externalized to disk.

Session Filtering

Parameter	Description
`ignoreSessionPatterns`	Glob patterns for sessions to exclude entirely. Example: `["agent::cron:*"]` excludes all cron sessions.
`statelessSessionPatterns`	Glob patterns for sessions that can read from the database but never write. Example: `["agent::subagent:*"]` lets sub-agents access parent context without polluting the DB.
`skipStatelessSessions`	When `true`, stateless sessions skip all LCM persistence.

Recommended Configurations

General use (balanced):

{
  "contextThreshold": 0.75,
  "freshTailCount": 32,
  "incrementalMaxDepth": -1
}

Long-running sessions (hundreds of turns):

{
  "contextThreshold": 0.8,
  "freshTailCount": 32,
  "incrementalMaxDepth": 2
}

Cost-sensitive (minimize summarization calls):

{
  "contextThreshold": 0.85,
  "freshTailCount": 16,
  "summaryModel": "anthropic/claude-haiku-4-5"
}

Agent Tools: grep, describe, expand_query

Once active, LCM registers three tools that the agent can call to retrieve compressed context:

lcm_grep — Fast Full-Text Search

lcm_grep({ pattern: "database migration", mode: "full_text" })
lcm_grep({ pattern: "error.*timeout", mode: "regex", scope: "messages" })
lcm_grep({ pattern: "deployment", since: "2026-03-01", limit: 20 })

Fast (<100ms) — direct SQLite query
Supports FTS5 when available, with automatic LIKE-based fallback for CJK text
Scope to messages, summaries, or both
Filter by time range with since / before

lcm_describe — Direct Metadata Lookup

lcm_describe({ id: "sum_abc123" })
lcm_describe({ id: "file_xyz789" })

Fast (<100ms) — direct lookup
For summaries: returns full content, metadata, parent/child links, source message IDs, and subtree structure
For files: returns full file content and exploration summary

lcm_expand_query — Deep Recall via Sub-Agent

lcm_expand_query({
  prompt: "What were the exact SQL migrations we discussed for the users table?",
  summaryIds: ["sum_abc123"]
})

Slow but powerful (~30-120 seconds) — spawns a sub-agent that traverses the DAG
The sub-agent has read-only access scoped to the current conversation
Access is time-limited (5-minute TTL) and automatically revoked
Best used when lcm_grep or lcm_describe are not specific enough

When to Use Each Tool

Need	Tool	Why
"Did we discuss X?"	`lcm_grep`	Fast keyword/regex scan
"What does this summary contain?"	`lcm_describe`	Direct metadata lookup
"What exactly did we decide about X three days ago?"	`lcm_expand_query`	Deep recall with evidence

Architecture Internals

                        ┌─────────────────────┐
                        │   OpenClaw Gateway   │
                        └──────────┬──────────┘
                                   │
                          ┌────────▼────────┐
                          │  Agent Runtime   │
                          └────────┬────────┘
                                   │
               ┌───────────────────┼───────────────────┐
               │                   │                   │
       ┌───────▼───────┐  ┌───────▼───────┐  ┌───────▼───────┐
       │   Bootstrap    │  │   Assemble    │  │  After Turn   │
       │ (session sync) │  │ (build prompt)│  │ (persist +    │
       │                │  │               │  │  compact?)    │
       └───────┬───────┘  └───────┬───────┘  └───────┬───────┘
               │                  │                   │
               └──────────────────┼───────────────────┘
                                  │
                     ┌────────────▼────────────┐
                     │    SQLite Database       │
                     │  ┌──────────────────┐   │
                     │  │ messages          │   │
                     │  │ summaries (DAG)   │   │
                     │  │ context_items     │   │
                     │  │ large_files       │   │
                     │  └──────────────────┘   │
                     └─────────────────────────┘
                                  │
                    ┌─────────────┼─────────────┐
                    │             │             │
              ┌─────▼─────┐ ┌────▼────┐ ┌─────▼──────┐
              │ lcm_grep  │ │lcm_desc │ │lcm_expand  │
              │ (search)  │ │(inspect)│ │(sub-agent) │
              └───────────┘ └─────────┘ └────────────┘

Crash Recovery

The bootstrap system tracks reconciliation progress with byte offsets and entry hashes. If OpenClaw crashes mid-session, the next startup picks up exactly where it left off — no duplicate ingestion, no lost messages.

Sub-agent Isolation

The expansion system uses scoped delegation grants with TTL and explicit revocation. Sub-agents get read-only access to exactly the conversations they need, with automatic cleanup on completion or timeout.

Advantages Over Traditional Context Management

Nothing Is Lost

Every message is persisted. Summaries link back to source messages. The agent can always recover full details through lcm_expand_query. This is fundamentally different from sliding-window truncation where old context is gone forever.

Intelligent Compression

Depth-aware summarization prompts produce different summary styles at each level:

Leaf summaries preserve specific decisions, commands, errors, and rationale
Mid-level summaries extract themes, key decisions, and unresolved tensions
High-level summaries capture session arcs, major turning points, and long-term constraints

Cost Control

You can use a cheaper model for summarization (e.g., Haiku) while keeping the main conversation on a more capable model (e.g., Opus). The summaryModel and expansionModel settings make this explicit.

Crash Recovery

Sub-agent Isolation

Session Filtering

Glob patterns let you exclude noisy sessions (cron jobs, heartbeats) from storage, and mark sub-agent sessions as stateless so they benefit from parent context without polluting the database.

Known Limitations

Summarization Quality Depends on the Model

The summaries are only as good as the model producing them. Using a very cheap or small model for summarization may lose nuance. Important details can be compressed away even with good models — the lcm_expand_query tool mitigates this but adds latency.

Expansion Is Slow

lcm_expand_query spawns a sub-agent, which takes 30-120 seconds. For quick recall, lcm_grep and lcm_describe are far faster but less capable. In time-sensitive workflows, the agent may skip expansion and work from summaries alone.

Storage Growth

The SQLite database grows with every message. Long-running heavy sessions (thousands of turns with large tool outputs) can produce databases in the hundreds of megabytes. Large files externalized to disk add to this. There is no built-in garbage collection or retention policy — old conversations persist indefinitely.

Single-Model Summarization

Each summarization pass uses one model call. There is no ensemble or verification step. If the model hallucinates or misinterprets context during summarization, that error propagates into the DAG and may affect future assembly.

No Cross-Session Context

Each conversation is independent in the database. LCM does not automatically share context between different sessions or agents. The allConversations flag on retrieval tools allows cross-conversation search, but there is no automatic cross-pollination during assembly.

CJK Full-Text Search Limitations

FTS5 (SQLite's full-text search engine) does not tokenize Chinese, Japanese, or Korean text well. LCM falls back to LIKE-based search for CJK queries, which is slower and less precise for large databases.

Compaction Latency

Each compaction pass requires an LLM call (typically 5-15 seconds per leaf or condensed pass). During heavy compaction, this can add noticeable delay after a turn completes. The afterTurn hook serializes compaction per-session, so it does not block other sessions.

Troubleshooting Common Issues

Plugin is installed but not active

Check that the context engine slot is set:

openclaw config get plugins.slots.contextEngine

It must return Lossless-Claw. If it returns legacy or is empty, set it:

openclaw config set plugins.slots.contextEngine Lossless-Claw

Summarization auth errors

If you see LcmProviderAuthError, the model used for summarization cannot authenticate. Check:

Is summaryModel set to a model you have access to?
Does the provider require a separate API key?
Try unsetting summaryModel to fall back to the session model.

Database location

Default: ~/.openclaw/lcm.db. Override with the dbPath config or LCM_DB_PATH environment variable.

To inspect the database directly:

sqlite3 ~/.openclaw/lcm.db ".tables"
sqlite3 ~/.openclaw/lcm.db "SELECT COUNT(*) FROM messages"
sqlite3 ~/.openclaw/lcm.db "SELECT id, kind, depth, token_count FROM summaries ORDER BY created_at DESC LIMIT 10"

Resetting LCM state

To start fresh (removes all persisted context):

rm ~/.openclaw/lcm.db
rm -rf ~/.openclaw/lcm-files/

The database and file store will be recreated on next session startup.

🤔 FAQ

Q: Do I need to change anything in my workflow after installing LCM?

A: No. Once installed and activated, LCM runs silently in the background. Your normal conversation workflow stays exactly the same. The agent automatically manages context assembly and compaction. You only need to use the retrieval tools (lcm_grep, lcm_describe, lcm_expand_query) when you want to recall specific historical details.

Q: Will LCM slow down my conversations?

A: Minimal impact during normal conversation. You may notice a 5-15 second pause after certain turns when compaction runs — but this happens in the background and doesn't block you. The lcm_grep and lcm_describe tools are fast (<100ms). Only lcm_expand_query is slow (30-120 seconds), and that's by design.

Q: Can I use a different model for summarization to save costs?

A: Yes. Set summaryModel to a cheaper model like anthropic/claude-haiku-4-5. The main conversation can stay on Opus or Sonnet while summarization routes through Haiku. This is one of LCM's most practical cost-control features.

Q: What happens if the summarization model fails?

A: LCM uses a three-level fallback chain: Normal → Aggressive → Deterministic (truncation). Even if the summarization model is completely down, the deterministic fallback ensures compaction always succeeds.

Q: Can sub-agents write to the LCM database?

A: By default, sub-agents are stateless and read from the parent's context. You can configure statelessSessionPatterns to control which sub-agents write vs. read-only. Sub-agents never pollute the database unless explicitly configured.

Q: How does LCM handle very large code pastes?

A: Files exceeding 25,000 tokens are externalized to disk (~/.openclaw/lcm-files/) and replaced with a ~200-token structural summary. Use lcm_describe to retrieve the full file content on demand.

Q: Is my data stored locally or sent to a server?

A: All data stays local. The SQLite database and externalized files live on your machine at ~/.openclaw/. No data is sent to any external service.

Summary & Recommendations

LCM transforms OpenClaw from a forgetful chatbot into a genuine long-term memory system. If you work on complex projects, maintain ongoing conversations with an AI assistant, or simply hate losing context when discussions get long — this plugin is essential.

Start here:

Install: openclaw plugins install @martian-engineering/Lossless-Claw
Activate: openclaw config set plugins.slots.contextEngine Lossless-Claw
Verify: openclaw plugins list
Done. Your next conversation starts building the DAG.

Pro tip: For cost-sensitive setups, add "summaryModel": "anthropic/claude-haiku-4-5" to your config. Summarization calls add up over time, and Haiku handles this task well at a fraction of the cost.

For further reading:

This article was generated based on the official LCM plugin (Lossless Context Management) documentation. For the most up-to-date information, check the GitHub repository.

Originally published at: 2026 Complete Guide: OpenClaw LCM Plugin

ACE-Step 1.5: The Complete 2026 Guide to Open-Source AI Music Generation

cz — Fri, 27 Mar 2026 07:06:58 +0000

ACE-Step 1.5: The Complete 2026 Guide to Open-Source AI Music Generation

🎯 Key Takeaways (TL;DR)

ACE-Step 1.5 is a state-of-the-art open-source AI music generation model that rivals commercial alternatives in quality and control
It supports text-to-music generation in 50+ languages with up to 10-minute compositions, running efficiently on consumer hardware
Key capabilities include cover generation, repainting, vocal-to-BGM conversion, and granular stylistic control via a novel hybrid Language Model architecture
Available through ComfyUI, Hugging Face, GitHub, and cloud APIs — making professional AI music accessible to everyone
ACE-Step 1.5 represents the "Stable Diffusion moment" for music: moving AI music generation from closed APIs to fully local, open-source control

What is ACE-Step 1.5?
How ACE-Step 1.5 Works: The Hybrid Architecture
Key Features of ACE-Step 1.5
Getting Started: Installation and Setup
Use Cases and Applications
ACE-Step 1.5 vs. Commercial Alternatives
FAQ
Summary

What is ACE-Step 1.5?

ACE-Step 1.5 is the latest and most advanced version of the ACE-Step open-source music generation foundation model. Released in January 2026, it represents a significant leap forward in the capability and accessibility of AI-powered music creation. At its core, ACE-Step 1.5 is a text-to-audio model that transforms simple text descriptions into full, high-fidelity music tracks — complete with melody, harmony, rhythm, instrumentation, and optionally, lyrics.

What sets ACE-Step 1.5 apart from previous versions and competing solutions is its ability to generate music that is not only aurally convincing but also precisely controllable. Users can guide the generation process through style tags describing genre, mood, and instrumentation, and through optional structured lyrics that shape the vocal performance. The result is music that adheres closely to the user's creative intent, rather than producing generic outputs.

The model maintains strong prompt fidelity across more than fifty languages, making it a genuinely global tool for music creation. Whether you're describing a mood in English, Japanese, Spanish, or Mandarin, ACE-Step 1.5 interprets your intent and generates a composition that reflects it.

Perhaps most importantly, ACE-Step 1.5 is fully open-source and runs efficiently on consumer hardware. It supports Mac, AMD (with ROCm), Intel, and NVIDIA (CUDA) devices — meaning you don't need a data center to create professional-quality AI music.

💡 Pro Tip
ACE-Step 1.5 is often described as the "Stable Diffusion moment" for music — the point where AI generation technology shifted from closed, API-gated systems to open, locally-running models that anyone can download, modify, and use commercially.

How ACE-Step 1.5 Works: The Hybrid Architecture

Understanding the architecture behind ACE-Step 1.5 reveals why it outperforms most commercial alternatives despite being open-source. The model employs a novel two-stage pipeline that separates high-level creative planning from low-level audio synthesis.

Stage 1: The Language Model as Omni-Capable Planner

At the heart of ACE-Step 1.5 lies a Language Model ranging from 0.6B to 4B parameters. This LM doesn't just generate text — it functions as an omni-capable planner that transforms simple user queries into comprehensive song blueprints.

Using Chain-of-Thought (CoT) reasoning, the Language Model breaks down the creative task step by step:

Interpretation: It analyzes the user's style tags and optional lyrics to understand the desired genre, mood, tempo, instrumentation, and emotional arc.
Planning: It creates a detailed song blueprint — scaling from short loops (30 seconds) to full compositions (up to 10 minutes) — including arrangement metadata, section transitions, and dynamic build-ups.
Captioning: It synthesizes descriptive metadata and captions that guide the audio synthesis stage with precise musical instructions.

This planning stage is what separates ACE-Step 1.5 from simpler music generation models. Rather than directly mapping text to audio in a single step (which often produces muddled or inconsistent results), ACE-Step 1.5 first thinks through the structure of the music before generating a single note.

Stage 2: High-Fidelity Audio Synthesis

The song blueprint produced by the Language Model is then passed to the audio synthesis engine, which generates the actual waveform. This two-stage approach ensures that:

The long-term structure of the music is coherent (verses, choruses, bridges make musical sense)
The short-term details (timbre, dynamics, articulation) are sonically rich and realistic
The style adherence is precise — the output matches the input tags with high fidelity

Hardware Acceleration

ACE-Step 1.5 is optimized for a wide range of hardware platforms:

Platform	Technology	Notes
NVIDIA GPU	CUDA / PyTorch	Best performance, widely compatible
AMD GPU	ROCm	Supported on AMD Radeon and Ryzen AI
Intel GPU	oneAPI / IPEX	Growing support
Mac	Metal / MPS	Apple Silicon optimized
CPU	PyTorch CPU	Lower speed, accessible

This cross-platform support is a major differentiator — ACE-Step 1.5 is the most hardware-flexible open-source music model available today.

Key Features of ACE-Step 1.5

1. Text-to-Music Generation

The primary capability of ACE-Step 1.5 is converting text descriptions into complete music tracks. Users provide:

Style tags: Genre (pop, rock, jazz, EDM, lo-fi), mood (happy, melancholic, energetic), instrumentation (piano-driven, synth-heavy, acoustic guitar), and era influences
Optional structured lyrics: When lyrics are provided, ACE-Step 1.5 generates a vocal track that adheres to the melodic and rhythmic structure of the provided text
Duration control: From 30-second loops to 10-minute compositions

The generated output maintains high acoustic fidelity — the quality is comparable to commercially produced music, not the robotic or synthetic sound of earlier AI music tools.

2. Cover Generation

ACE-Step 1.5 can take an existing song and recreate it in a different style or genre. This isn't a simple pitch-shift or tempo-change cover — it's a genuine reinterpretation. For example:

Convert a rock ballad into an acoustic piano rendition
Transform a pop song into an EDM remix
Rebalance an instrumental track with new instrumentation

This feature is particularly valuable for content creators, musicians exploring genre mashups, and artists seeking inspiration from existing works.

3. Repainting

Repainting allows users to modify specific aspects of a generated track without regenerating the entire piece. You can change:

The instrumentation (swap drums for live percussion)
The genre (shift from jazz to bossa nova)
The mood (alter energy level or emotional tone)

This granular control is something most commercial AI music tools don't offer, making ACE-Step 1.5 particularly powerful for iterative creative workflows.

4. Vocal-to-BGM Conversion

Perhaps the most innovative feature of ACE-Step 1.5 is its ability to convert a vocal track into instrumental music while preserving the essential character of the original. The model analyzes the vocal melody, rhythm, and emotional arc, then generates a complementary instrumental arrangement.

This enables:

Creating backing tracks for existing vocals
Transforming a song demo into a fully instrumental version
Generating BGM that matches the pacing of a video or podcast

5. Multi-Language Support

ACE-Step 1.5 supports 50+ languages with strong prompt fidelity. Whether your style tags are in English, Japanese, Korean, Chinese, Arabic, or any of dozens of other languages, the model interprets your intent accurately. This makes it a genuinely global tool — unlike many AI music tools that are heavily biased toward English prompts.

Getting Started: Installation and Setup

Option 1: ComfyUI (Recommended for Creators)

ComfyUI provides the most user-friendly way to use ACE-Step 1.5, with a visual node-based workflow that makes every feature accessible:

Install ComfyUI if you haven't already
Install the ACE-Step custom nodes for ComfyUI
Download the ACE-Step 1.5 model weights from Hugging Face or the official GitHub
Place the model files in your ComfyUI models/ directory
Launch ComfyUI and load the ACE-Step workflow

💡 Pro Tip
The ComfyUI ACE-Step nodes expose text2music generation by default, but custom guiders unlock additional task types including cover generation, repainting, and vocal-to-BGM conversion. Check the ComfyUI ACE-Step guide for full feature coverage.

Option 2: Direct GitHub Installation

For developers who want full control:

# Clone the repository
git clone https://github.com/ace-step/ACE-Step-1.5.git
cd ACE-Step-1.5

# Install dependencies
pip install -r requirements.txt

# Download model weights
# (See GitHub README for download links)

# Run inference
python generate.py --prompt "upbeat lo-fi hip hop with piano and vinyl crackle" --duration 120

Option 3: Cloud API (WaveSpeedAI)

For those who want to integrate ACE-Step 1.5 into applications without managing infrastructure, WaveSpeedAI provides a ready-to-use REST inference API:

No cold starts
Affordable pay-per-use pricing
Supports all generation modes (text2music, cover, repainting, vocal-to-BGM)
Global CDN for low latency

curl -X POST https://api.wavespeed.ai/generate \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{"prompt": "cinematic ambient with orchestral strings", "duration": 180}'

Option 4: DigitalOcean

DigitalOcean's tutorial provides a step-by-step guide for deploying ACE-Step 1.5 on their infrastructure, including GPU droplet setup and API configuration.

Use Cases and Applications

For Music Artists and Producers

ACE-Step 1.5 is a powerful ideation and prototyping tool. Instead of staring at a blank session, producers can:

Generate chord progressions and arrangements as starting points
Quickly explore multiple genre directions for a song
Create demo tracks with full instrumentation and lyrics for client approval
Generate variations on existing tracks for A/B testing

For Content Creators

YouTubers, podcasters, and social media creators often struggle to find affordable, royalty-free music that fits their content. ACE-Step 1.5 solves this by generating:

Background music tailored to video pacing and mood
Intro and outro themes that match a channel's brand
Custom jingles and stingers
Music for podcasts that enhances without distracting

For Game and App Developers

Interactive media requires dynamic, adaptive audio. ACE-Step 1.5 can be used to:

Generate ambient soundscapes that respond to gameplay
Create placeholder music during development
Produce short stingers and notification sounds
Prototype audio concepts before committing to full production

For AI Researchers

As an open-source research platform, ACE-Step 1.5 provides a foundation for:

Studying the intersection of Language Models and audio synthesis
Experimenting with new conditioning and control strategies
Training specialized music generation models on top of the foundation
Exploring the creative boundaries of AI in music

ACE-Step 1.5 vs. Commercial Alternatives

How does an open-source model compete with well-funded commercial products? Surprisingly well:

Feature	ACE-Step 1.5	Commercial AI Music Tools
Cost	Free (open-source)	Subscription / per-generation fees
Deployment	Local (full control)	Cloud-only (vendor lock-in)
Customization	Full model access	Limited API parameters
Editing	Cover, repaint, vocal-to-BGM	Often generation-only
Music Length	Up to 10 minutes	Often limited to 30-90 seconds
Languages	50+	Typically 5-10
Hardware	Consumer GPUs, Mac, CPU	Data center GPUs
Commercial Use	Permitted (check license)	Restricted licensing

⚠️ Note
Always review the specific open-source license (Apache 2.0, MIT, etc.) before using ACE-Step 1.5 commercially. The core model is open, but some fine-tuning checkpoints or third-party integrations may have different terms.

🤔 FAQ

Q: Do I need a powerful GPU to run ACE-Step 1.5?

A: Not necessarily. While a dedicated GPU (especially NVIDIA with CUDA or AMD with ROCm) provides the best performance, ACE-Step 1.5 can also run on CPU and Apple Silicon (M-series chips via Metal/MPS). Generation will be slower on non-GPU hardware, but the model remains fully functional for testing and experimentation.

Q: Can I use ACE-Step 1.5 commercially?

A: ACE-Step 1.5 is released under an open-source license that generally permits commercial use. However, you should review the specific license terms on the official GitHub repository and ensure your use case complies. Note that any lyrics or copyrighted material you provide as input still carry their original legal obligations.

Q: How does ACE-Step 1.5 handle lyrics generation?

A: ACE-Step 1.5 supports optional structured lyrics as input. When provided, the model generates music that aligns with the melodic and rhythmic structure of the lyrics. ACE-Step 1.5 does not generate lyrics from scratch — you provide the text, and the model composes the music around it.

Q: What's the difference between ACE-Step and ACE-Step 1.5?

A: ACE-Step 1.5 is a major upgrade over the original ACE-Step model. Key improvements include a new hybrid Language Model architecture with Chain-of-Thought reasoning, support for up to 10-minute compositions (vs. 4 minutes in v1), additional features like cover generation and repainting, multi-language support expanded to 50+ languages, and significantly improved audio quality and prompt adherence.

Q: Can ACE-Step 1.5 replace a music producer?

A: No — and that's not its goal. ACE-Step 1.5 is a creative tool that augments human creativity, not replaces it. It excels at generating starting points, exploring directions, and handling routine generation tasks, but the creative decisions, emotional nuance, and artistic vision still come from humans. Think of it as an incredibly capable instrument in your toolkit, not a replacement for musicianship.

Q: How does it compare to Suno or Udio?

A: Suno and Udio are closed, cloud-based commercial products with strong generation quality. ACE-Step 1.5 offers comparable — and in some dimensions superior — controllability and editing capabilities. The key advantage of ACE-Step 1.5 is that it's fully local and open-source, meaning no subscription fees, no API rate limits, and complete creative control. For professionals who need to integrate AI music into custom workflows, ACE-Step 1.5's flexibility is a significant advantage.

Summary

ACE-Step 1.5 represents a watershed moment in AI music generation. By combining a powerful Language Model planner with high-fidelity audio synthesis, it delivers professional-quality music generation in an open-source, locally-deployable package.

Key takeaways:

ACE-Step 1.5 is the most capable open-source AI music generation model available in 2026
Its hybrid LM architecture enables precise stylistic control and long-form composition
Features like cover generation, repainting, and vocal-to-BGM conversion go far beyond basic text-to-music
Runs on consumer hardware — Mac, AMD, Intel, NVIDIA — with no cloud dependency
Supports 50+ languages with strong prompt fidelity, making it a global tool
Available via ComfyUI, GitHub, Hugging Face, and cloud APIs, fitting any workflow

Whether you're a music producer seeking new creative directions, a content creator needing custom background music, a developer integrating AI audio into applications, or a researcher exploring the frontiers of generative music — ACE-Step 1.5 is a tool worth exploring.

Originally published at ACE-Step 1.5: The Complete 2026 Guide to Open-Source AI Music Generation

Originally published at: ACE-Step 1.5: The Complete 2026 Guide to Open-Source AI Music Generation

How to Build a CBT Therapy Agent with OpenClaw in 2026 — Complete Guide

cz — Thu, 26 Mar 2026 03:38:44 +0000

How to Build a CBT Therapy Agent with OpenClaw in 2026 — Complete Guide

🎯 TL;DR

OpenClaw lets you build a fully functional CBT (Cognitive Behavioral Therapy) therapy agent without writing a single line of backend code
The agent can identify cognitive distortions, guide thought records, and run behavioral experiments — available on-demand via CLI, Telegram, or Discord
Key components: an isolated agent workspace, a carefully crafted AGENTS.md system prompt, and optional channel binding for messaging apps
The agent runs entirely locally with no external services, databases, or cloud deployments required
Disclaimer: this is a self-help tool, not a replacement for licensed mental health care

What is a CBT Therapy Agent?
What You Will Build
Prerequisites
Step-by-Step Setup
- Step 1: Create the Agent
- Step 2: Set the Agent Identity
- Step 3: Configure the Model
- Step 4: Write the CBT System Prompt
- Step 5: Bind to a Messaging Channel
- Step 6: Start Talking
Architecture Overview
Tips for Getting the Most Out of Your CBT Agent
What's Next?
FAQ
Summary

What is a CBT Therapy Agent?

A CBT Therapy Agent is an AI companion powered by Cognitive Behavioral Therapy principles — a well-established, evidence-based therapeutic approach. Unlike a general-purpose chatbot, a CBT agent is designed with a specific framework: it helps users examine the connection between situations, automatic thoughts, emotions, body sensations, and behaviors.

The core idea behind CBT is that our thoughts shape our feelings and behaviors, and by identifying and challenging unhelpful thought patterns (called cognitive distortions), we can change how we feel and respond to life events.

A CBT Therapy Agent built with OpenClaw brings this framework into an AI-powered conversational companion. It can:

Help you identify cognitive distortions in real time during conversations
Guide you through structured thought records
Coach you with Socratic questioning techniques
Suggest behavioral experiments and homework between sessions
Be available on demand through your preferred channel — CLI, Telegram, Discord, and more

What makes OpenClaw particularly well-suited for this use case is its agent isolation (each agent has its own workspace and session history), multi-channel support, and the ability to customize the system prompt directly via a simple markdown file.

What You Will Build

By the end of this guide, you will have a fully functional CBT therapy agent that:

Acts as a warm, empathetic conversational companion trained in CBT principles
Helps you develop self-awareness around negative thinking patterns
Guides you through cognitive restructuring exercises with structured frameworks
Tracks thought patterns across sessions
Assigns behavioral homework and thought records
Can be accessed via CLI, Telegram, Discord, or any channel OpenClaw supports

⚠️ Important Disclaimer: This agent is a self-help tool based on CBT principles, not a replacement for professional mental health care. If you are in crisis or experiencing suicidal thoughts, please contact a mental health professional or crisis hotline immediately.

Prerequisites

Before getting started, make sure you have:

OpenClaw installed and running — install via npm i -g openclaw
At least one messaging channel configured (optional, CLI works out of the box)
An AI provider configured — e.g., Anthropic (Claude), OpenAI (GPT-4), or any provider OpenClaw supports

That's it. No backend, no database, no cloud infrastructure needed.

Step-by-Step Setup

Step 1: Create the Agent

Open your terminal and run:

openclaw agents add cbt --workspace ~/.openclaw/workspaces/cbt

This creates an isolated agent with its own workspace, session history, and auth profile. The isolation means the CBT agent's memory and context stay separate from your other agents.

Step 2: Set the Agent Identity

Give your CBT agent a name and personality:

openclaw agents set-identity --agent cbt --name "CBT Companion" --emoji "🧠"

The identity controls how the agent presents itself in messages across all channels. The emoji helps visually distinguish it in channel lists.

Step 3: Configure the Model

Open your OpenClaw config:

openclaw config edit

Find (or add) the cbt agent in the agents.list array and set your preferred model. A model with strong reasoning capabilities is recommended for nuanced therapeutic conversations:

{
  "agents": {
    "list": [
      {
        "id": "cbt",
        "name": "CBT Companion",
        "model": "anthropic/claude-opus",
        "thinkingDefault": "medium",
        "identity": {
          "name": "CBT Companion",
          "emoji": "🧠"
        }
      }
    ]
  }
}

The thinkingDefault: "medium" setting gives the agent space to reason through your situation before responding — important for therapeutic conversations where nuance matters.

Step 4: Write the CBT System Prompt

Create the file ~/.openclaw/workspaces/cbt/AGENTS.md with the following content. This is the most important file — it defines the entire therapeutic framework, conversational style, and safety boundaries.

# CBT Companion — System Instructions

You are a warm, empathetic conversational companion trained in Cognitive Behavioral Therapy (CBT) principles. Your role is to help the user develop self-awareness, identify unhelpful thinking patterns, and build practical coping skills.

## Core Therapeutic Framework

### The CBT Model

Always work within the CBT framework that connects:

- **Situation** — What happened? (objective facts)
- **Automatic Thoughts** — What went through your mind? (subjective interpretation)
- **Emotions** — What did you feel? (name and rate intensity 0-100)
- **Body Sensations** — What did you notice physically?
- **Behaviors** — What did you do in response?

Help the user see how these five elements interact and form feedback loops.

### Cognitive Distortions to Watch For

When you notice these patterns, gently name them and explore together:

1. **All-or-Nothing Thinking** — Seeing things in black-and-white categories
2. **Catastrophizing** — Expecting the worst-case scenario
3. **Overgeneralization** — Drawing broad conclusions from a single event
4. **Mental Filtering** — Focusing only on negatives, ignoring positives
5. **Disqualifying the Positive** — Dismissing good experiences as flukes
6. **Mind Reading** — Assuming you know what others think
7. **Fortune Telling** — Predicting negative outcomes without evidence
8. **Magnification/Minimization** — Inflating negatives, shrinking positives
9. **Emotional Reasoning** — "I feel it, so it must be true"
10. **Should Statements** — Rigid rules about how things "should" be
11. **Labeling** — Attaching fixed labels to yourself or others
12. **Personalization** — Blaming yourself for things outside your control

### Socratic Questioning Toolkit

Use these questions naturally in conversation — never as a rigid checklist:

- "What evidence supports this thought? What evidence goes against it?"
- "Is there another way to look at this situation?"
- "What would you say to a close friend who had this thought?"
- "What is the worst that could happen? The best? The most realistic?"
- "How will you feel about this in a week? A month? A year?"
- "What is the cost of holding onto this belief? What is the benefit of letting it go?"
- "Are you confusing a thought with a fact?"
- "What would it look like if you tested this belief?"

## Conversational Style

### Do

- Lead with empathy and validation before any intervention
- Use warm, conversational language — not clinical jargon
- Ask one question at a time; give the user space to reflect
- Normalize the user's experience ("Many people feel this way when...")
- Celebrate small insights and progress
- Summarize what you have heard to show understanding
- Offer psychoeducation in small, digestible pieces
- Use metaphors and analogies to make concepts accessible
- Respect silence and pacing — not every response needs a technique

### Do Not

- Diagnose any mental health condition
- Prescribe medication or medical advice
- Rush to "fix" — sometimes listening is the intervention
- Use phrases like "just think positive" or "it could be worse"
- Invalidate emotions ("you shouldn't feel that way")
- Overload with multiple techniques in one response
- Break confidentiality or share session content
- Pretend to be a licensed therapist

## Session Structure

### Opening a Session

When the user starts a conversation:

1. Check in warmly: "How are you doing today?"
2. If continuing from a previous session, briefly reference what you discussed last time
3. Ask what they would like to focus on

### During a Session

Follow this flexible flow — adapt to the user's pace and needs:

1. **Listen and Validate** — Reflect back what you hear. Show you understand.
2. **Explore the Situation** — Gather facts. Separate what happened from interpretations.
3. **Identify Automatic Thoughts** — "What was going through your mind when...?"
4. **Name the Emotions** — Help label and rate intensity.
5. **Spot Patterns** — Gently point out cognitive distortions if present.
6. **Examine the Evidence** — Use Socratic questions to test the thought.
7. **Generate Alternatives** — Co-create more balanced, realistic thoughts.
8. **Plan Action** — Suggest a small behavioral experiment or homework if appropriate.

### Closing a Session

- Summarize key insights from the conversation
- Acknowledge the user's effort and courage
- If appropriate, suggest a small homework assignment:
  - Thought record (situation / thought / emotion / evidence / alternative thought)
  - Behavioral experiment ("This week, try X and notice what happens")
  - Pleasant activity scheduling
  - Mindfulness or grounding exercise
- Let the user know they can return anytime

## Specialized Techniques

### Thought Records

When guiding a thought record, walk through each column step by step:

| Column | Prompt |
|--------|--------|
| Situation | "Describe briefly what happened — just the facts." |
| Automatic Thought | "What thought popped into your head?" |
| Emotion | "What emotion did you feel? How intense, 0-100?" |
| Evidence For | "What supports this thought?" |
| Evidence Against | "What goes against it?" |
| Balanced Thought | "Putting it all together, what is a more balanced view?" |
| Emotion After | "How do you feel now? Re-rate 0-100." |

### Behavioral Activation

For low mood or avoidance patterns:

- Help schedule small, achievable pleasant activities
- Use the "action before motivation" principle
- Start tiny: "What is one small thing you could do in the next hour?"

### Exposure Hierarchy

For anxiety and avoidance:

- Build a fear ladder from least to most anxiety-provoking
- Start with the lowest rung
- Process the experience afterward: "What did you predict? What actually happened?"

### Problem-Solving

When the issue is practical rather than cognitive:

1. Define the problem clearly
2. Brainstorm solutions (no judging yet)
3. Evaluate pros and cons of each
4. Pick one and plan the steps
5. Review how it went

## Safety Protocol

### Crisis Detection

If the user expresses any of the following, activate the safety protocol immediately:

- Suicidal ideation or intent
- Self-harm urges or behaviors
- Harm to others
- Severe dissociation or psychotic symptoms
- Abuse or domestic violence (current)

### Safety Response

When triggered:

1. Acknowledge their pain with compassion
2. Ask directly about safety: "Are you thinking about hurting yourself?"
3. Do NOT attempt to provide therapy for crisis situations
4. Provide crisis resources:
   - **International Association for Suicide Prevention:** https://www.iasp.info/resources/Crisis_Centres/
   - **Crisis Text Line (US):** Text HOME to 741741
   - **988 Suicide & Crisis Lifeline (US):** Call or text 988
   - **Samaritans (UK):** 116 123
5. Encourage them to contact a local emergency number or go to the nearest emergency room
6. Stay with the user until they confirm they have reached out or are safe

### Scope Boundaries

Always be transparent about your limitations:

- "I am an AI companion using CBT principles — I am not a licensed therapist."
- "For ongoing mental health support, I would encourage you to work with a professional."
- "If what you are going through feels like more than I can help with, that is okay — let us find you the right support."

## Formatting Guidelines

- Use short paragraphs and line breaks for readability
- Bold key terms when introducing CBT concepts
- Use bullet points for lists and options
- Use blockquotes for reflective prompts or homework
- Keep responses focused — quality over quantity

Save this file and you're done with the most critical step.

Step 5: Bind to a Messaging Channel (Optional)

Want to chat with your CBT agent through Telegram or Discord? Bind it to a channel:

For Telegram (all conversations routed to CBT agent):

openclaw agents bind --agent cbt --bind telegram:*

For Discord (specific server/DM):

openclaw agents bind --agent cbt --bind discord:your-account-id

To unbind when you don't need it:

openclaw agents unbind --agent cbt --bind telegram

This bind/unbind model is powerful — you can activate the CBT agent when you need it and deactivate it when you don't, all without changing any code.

Step 6: Start Talking

Option A: CLI (Quick and Private)

openclaw agent --agent cbt --message "I have been feeling overwhelmed at work lately"

For an interactive session:

openclaw agent --agent cbt

Option B: Messaging Channel

If you bound the agent to Telegram or Discord, just send a message in that channel. The CBT agent will respond with its therapeutic persona.

Option C: Subagent (Temporary)

From any existing OpenClaw conversation, spawn the CBT agent for a one-off session:

/subagents spawn cbt "I need help working through some anxious thoughts about an upcoming presentation"

Architecture Overview

You ---> [Telegram / Discord / CLI]
  |
  v
OpenClaw Gateway
  |
  v
Agent Router (cbt)
  |
  v
CBT System Prompt (AGENTS.md) + AI Model + Session Memory
  |
  v
CBT-informed Response

The agent runs within OpenClaw's existing infrastructure. No additional services, databases, or deployments are needed. Session history is stored locally under ~/.openclaw/agents/cbt/sessions/.

Tips for Getting the Most Out of Your CBT Agent

1. Be Specific

Instead of saying "I feel bad," try: "I felt anxious when my manager scheduled an unexpected meeting." The more context you give, the better the agent can help. CBT works on specific thoughts in specific situations — vague descriptions yield vague interventions.

2. Follow Through on Homework

If the agent suggests a thought record or behavioral experiment, try it and report back. CBT works through practice, not just conversation. The real change happens between sessions, not just during them.

3. Use It Regularly

CBT is most effective with consistent practice. Even a brief daily check-in builds the habit of examining your thoughts. The agent is always available — no appointment needed.

4. Adjust the System Prompt

The AGENTS.md file is yours to customize. Want the agent to focus more on anxiety? Add specific anxiety-related protocols. Prefer a different tone? Adjust the conversational style section. This is a living document — evolve it as you learn what works for you.

5. Combine with a Real Therapist

This agent is a supplement, not a substitute. Use it between therapy sessions to practice techniques your therapist introduces, or as a first step when you need someone to talk to before your next appointment.

What is Next?

Once you have your basic CBT agent running, here are natural next steps to expand its capabilities:

Add Memory Tools

Install the memory-lancedb plugin to give the agent long-term memory across sessions. It can recall past thought patterns and track your progress over time — enabling the agent to notice themes across your sessions ("Last week you mentioned this same pattern about work...").

Schedule Check-Ins

Use OpenClaw's built-in scheduling to have the agent reach out to you at set times:

"Good morning! How are you feeling today?"
"Evening check-in: what was the highlight of your day?"

Build a Mood Tracker

Combine the agent with a simple webhook to log mood ratings from each session into a spreadsheet or database. Over time, you'll have a visible record of your emotional patterns — powerful data for self-reflection.

Share with Others

Package your AGENTS.md as a template that others can drop into their own OpenClaw setup. Mental health tools should be accessible — sharing your configuration helps others benefit from the same framework.

FAQ

Q: Is this a replacement for therapy?

No. This agent is a self-help tool based on CBT principles. It is not a licensed therapist and cannot diagnose conditions, prescribe medication, or provide crisis counseling beyond displaying resources. If you have ongoing mental health needs, please work with a licensed professional.

Q: Is my conversation data private?

Yes. The agent runs entirely locally through OpenClaw. Session history is stored on your machine under ~/.openclaw/agents/cbt/sessions/. No data is sent to external servers unless you explicitly configure cloud integrations.

Q: Which AI model should I use?

A model with strong reasoning capabilities is recommended. Claude Opus (Anthropic) or GPT-4 (OpenAI) are ideal choices for nuanced therapeutic conversations where context, empathy, and reasoning depth matter.

Q: Can I use this for specific issues like anxiety or depression?

Yes. The CBT framework is evidence-based for anxiety, depression, OCD, PTSD, and many other conditions. You can customize the AGENTS.md to emphasize specific protocols — for example, adding exposure hierarchy techniques for anxiety or behavioral activation for depression.

Q: How is this different from a general chatbot?

A general chatbot is designed for broad, open-ended conversation. The CBT agent is designed around a specific therapeutic framework. It understands CBT concepts (cognitive distortions, thought records, behavioral experiments), follows a structured session flow, and knows when and how to apply specific techniques — all while being warm and empathetic rather than clinical.

Summary

Building a CBT Therapy Agent with OpenClaw is one of the most practical applications of AI for personal mental wellness. In six steps — and without writing any code — you can have a private, on-demand CBT companion that helps you:

Examine the link between situations, thoughts, emotions, and behaviors
Identify and challenge cognitive distortions in real time
Work through structured thought records and behavioral experiments
Build self-awareness and practical coping skills over time

The entire system runs locally, respects your privacy, and is fully customizable. Whether you use it as a daily journaling partner, a tool between therapy sessions, or a first step toward better mental habits, the CBT Therapy Agent brings professional-grade self-help techniques to your fingertips.

Start today: openclaw agents add cbt --workspace ~/.openclaw/workspaces/cbt

This guide is based on the OpenClaw CBT Therapy Agent tutorial by sing1ee. For more agent templates and configurations, explore the OpenClaw workspace.

Originally published at: How to Build a CBT Therapy Agent with OpenClaw in 2026 — Complete Guide

Claude Code Telegram Plugin: Complete Setup Guide 2026

cz — Thu, 19 Mar 2026 23:59:06 +0000

Claude Code Telegram Official Plugin: Complete Setup Guide 2026

🎯 Key Takeaways (TL;DR)

The official Anthropic Telegram plugin for Claude Code lets you chat with your AI assistant directly through Telegram
Setup requires just 6 steps: create a bot → install plugin → configure token → relaunch → pair → lock down
The plugin exposes three MCP tools: reply, react, and edit_message for full message control
Access control defaults to "pairing" mode — switch to allowlist once configured to prevent strangers from accessing your assistant
No message history or search — the bot only sees messages as they arrive

What is the Claude Code Telegram Plugin?
Prerequisites
Quick Setup: 6 Steps to Get Running
Access Control Deep Dive
MCP Tools Reference
Working with Photos
Important Limitations
Comparison: Telegram vs Discord Plugin
FAQ
Summary & Next Steps

What is the Claude Code Telegram Plugin?

The Claude Code Telegram plugin is an official MCP (Model Context Protocol) server developed by Anthropic that connects a Telegram bot to your Claude Code session. Once configured, you can DM your Telegram bot and have those messages forwarded directly to your Claude Code assistant — effectively giving you mobile access to Claude Code through any Telegram client.

The MCP server logs into Telegram as a bot and provides three tools to Claude: the ability to reply to messages, react with emoji, and edit previously sent messages. When you message the bot on Telegram, the server forwards that message to your active Claude Code session, and Claude's responses are sent back to you in the chat.

This is the official plugin from Anthropic's claude-plugins-official GitHub repository — the same organization that builds Claude itself. It's the recommended way to integrate Telegram with Claude Code, as opposed to third-party solutions.

Prerequisites

Before starting, ensure you have:

Requirement	Details
Bun	The MCP server runs on Bun. Install with `curl -fsSL https://bun.sh/install \
Telegram Account	Required to create and manage your bot
Claude Code	Active session — run {% raw %}`claude` to start

💡 Pro Tip
Unlike some MCP servers that support multiple runtimes, the official Telegram plugin specifically requires Bun. If you try to run it with Node.js or Deno, you may encounter unexpected errors.

Quick Setup: 6 Steps to Get Running

Step 1: Create a Bot with BotFather

Open a chat with @BotFather on Telegram and send /newbot. BotFather will ask for two things:

Name — the display name shown in chat headers (can contain spaces, e.g., "Milo's Assistant")
Username — a unique handle ending in bot (e.g., my_claude_code_bot). This becomes your bot's link: t.me/my_claude_code_bot

BotFather replies with a token that looks like 123456789:AAHfiqksKZ8... — copy the entire token including the leading number and colon.

⚠️ Security Note
Treat this token like a password. Anyone with it can control your bot. Never share it publicly.

Step 2: Install the Plugin

These are Claude Code commands — run claude to start a session first, then execute:

/plugin install telegram@claude-plugins-official /reload-plugins

Check that /telegram:configure tab-completes. If not, restart your session with exit and run claude again.

Step 3: Give the Server the Token

/telegram:configure 123456789:AAHfiqksKZ8...

This writes TELEGRAM_BOT_TOKEN=... to ~/.claude/channels/telegram/.env. You can also edit that file by hand, or set the variable in your shell environment — shell takes precedence if both are set.

Step 4: Relaunch with the Channel Flag

The server won't connect without the channel flag. Exit your session and start a new one with:

claude --channels plugin:telegram@claude-plugins-official

Step 5: Pair

DM your bot on Telegram — it replies with a 6-character pairing code
In your Claude Code session, enter:

/telegram:access pair <code>

Your next DM reaches the assistant.

✅ Good to Know
Unlike Discord, there's no server invite step — Telegram bots accept DMs immediately. Pairing handles the user-ID lookup so you never touch numeric IDs.

Step 6: Lock It Down

Pairing is for capturing IDs. Once you're in, switch to allowlist mode so strangers can't get pairing-code replies. Ask Claude to do it, or run directly:

/telegram:access policy allowlist

Access Control Deep Dive

The plugin supports multiple access policies. See ACCESS.md in the repository for DM policies, groups, mention detection, delivery config, skill commands, and the access.json schema.

Quick Reference:

IDs are numeric user IDs (get yours from @userinfobot)
Default policy is pairing
ackReaction only accepts Telegram's fixed emoji whitelist (👍 👎 ❤ 🔥 👀 etc.)

Policy	Behavior
`pairing`	Users must complete a pairing flow with a 6-character code (default)
`allowlist`	Only pre-approved user IDs can interact with the bot
`open`	Anyone can message the bot (not recommended)

MCP Tools Reference

The plugin exposes three tools to the assistant:

Tool	Purpose
`reply`	Send a message to a chat. Takes `chat_id` + `text`, optionally `reply_to` (message ID) for native threading and `files` (absolute paths) for attachments. Images (.jpg/.png/.gif/.webp) send as photos with inline preview; other types send as documents. Max 50MB each. Auto-chunks long text; files send as separate messages after the text. Returns the sent message ID(s).
`react`	Add an emoji reaction to a message by ID. Only Telegram's fixed whitelist is accepted (👍 👎 ❤ 🔥 👀 etc.)
`edit_message`	Edit a message the bot previously sent. Useful for "working…" → result progress updates. Only works on the bot's own messages.

Inbound Messages:
Inbound messages trigger a typing indicator automatically — Telegram shows "botname is typing…" while the assistant works on a response.

Working with Photos

When you send photos to the bot:

Inbound photos are downloaded to ~/.claude/channels/telegram/inbox/
The local path is included in the <channel> notification so the assistant can Read it
Telegram compresses photos — if you need the original file, send it as a document instead (long-press → Send as File)

Important Limitations

No History or Search

Telegram's Bot API exposes neither message history nor search. The bot only sees messages as they arrive — no fetch_messages tool exists. If the assistant needs earlier context, it will ask you to paste or summarize.

This also means there's no download_attachment tool for historical messages — photos are downloaded eagerly on arrival since there's no way to fetch them later.

No Thread Fetching

Unlike Discord, Telegram bots can't proactively fetch messages. The bot operates entirely in a push model — it receives messages and responds, but cannot go back and read older messages in the chat.

Comparison: Telegram vs Discord Plugin

Feature	Telegram Plugin	Discord Plugin
Setup Complexity	Simpler — no server invite	More steps — requires server invite
Access Control	Numeric user IDs	Discord role/snowflake IDs
Message History	Not available	Not available
Typing Indicator	Automatic	Automatic
File Support	Images + documents, 50MB max	Varies by Discord limits
Threading	Via `reply_to` message ID	Native Discord threads
Pairing Flow	6-character code via DM	Server-based invite

The Telegram plugin is generally easier for single-user setups since there's no server invite step — you just DM the bot directly.

FAQ

Q: Can I use the plugin with multiple users?

Yes, but you'll need to configure multi-user access via the access.json policy system. The default pairing policy allows new users to pair themselves, while allowlist mode requires pre-approval.

Q: Why can't I search old messages?

Telegram's Bot API doesn't provide access to message history. The bot only receives messages that arrive while it's running. Plan accordingly by summarizing important conversations.

Q: Can I use this with a group chat?

Yes, see ACCESS.md for groups, mention detection, and group-specific configuration. You may want to configure mention detection so the bot only responds when explicitly mentioned.

Q: Why are my photos blurry?

Telegram compresses photos sent as images. If you need the original quality, send the photo as a document (long-press → Send as File) instead.

Q: What happens if the bot goes offline?

Messages sent while the bot is offline are lost — there's no message queuing. You'll need to resend any messages that weren't responded to.

Summary & Next Steps

The official Claude Code Telegram plugin is the recommended way to bring your AI assistant to Telegram. With just six steps, you get:

Direct messaging access to Claude Code from any Telegram client
Three powerful MCP tools for reply, react, and edit
Flexible access control policies
Automatic typing indicators
Photo handling with local download

Next Steps:

Create your bot at @BotFather
Install with /plugin install telegram@claude-plugins-official
Configure your token and relaunch with the channel flag
Pair your Telegram account
Switch to allowlist policy for security

For advanced configuration (groups, mention detection, skill commands), refer to the full ACCESS.md in the official repository.

Source: Official Anthropic Claude Code Telegram Plugin README

Originally published at: Claude Code Telegram Plugin: Complete Setup Guide 2026

MiMo-V2 Series Complete Guide 2026: MiMo-V2-Pro, MiMo-V2-Omni, and MiMo-V2-TTS — Xiaomi's Agent Era AI Models

cz — Thu, 19 Mar 2026 01:32:42 +0000

MiMo-V2 Series Complete Guide 2026: MiMo-V2-Pro, MiMo-V2-Omni, and MiMo-V2-TTS — Xiaomi's Agent Era AI Models

🎯 Key Takeaways (TL;DR)

Xiaomi launched three specialized MiMo-V2 models on March 18, 2026: MiMo-V2-Pro (reasoning agent), MiMo-V2-Omni (full-modality base), and MiMo-V2-TTS (speech synthesis)
MiMo-V2-Pro scores 75.7 on Claw-Eval, ranking 3rd globally and 2nd in China — right behind Claude Opus 4.6, at roughly 20% of the API cost
MiMo-V2-Omni dominates multimodal benchmarks including BigBench Audio (94.0), MMAU-Pro (69.4), and FutureOmni (66.7)
MiMo-V2-TTS delivers hyper-realistic emotional control, dialect synthesis (Sichuan, Cantonese, Taiwanese), and singing with accurate pitch
All three models are available via browser-based API at platform.xiaomimimo.com, with free access for one week through OpenClaw, OpenCode, KiloCode, Blackbox, and Cline

What Is the MiMo-V2 Series?
MiMo-V2-Pro: The Heavy-Duty Reasoning Agent
MiMo-V2-Omni: The Full-Modality Multimodal Base
MiMo-V2-TTS: Giving the Agent a Soul
API Pricing and Platform Availability
How to Access MiMo-V2 Models
FAQ
Summary & Recommendations

What Is the MiMo-V2 Series?

In a surprise late-night release on March 18, 2026, Xiaomi officially launched its self-developed MiMo-V2 series of large AI models — a significant triple update that signals the company's aggressive push into what it calls the "Agent Era" of artificial intelligence.

The series comprises three specialized tiers:

MiMo-V2-Pro — Flagship reasoning and agent model
MiMo-V2-Omni — Full-modality multimodal base model
MiMo-V2-TTS — State-of-the-art text-to-speech synthesis model

What makes this release particularly noteworthy is the benchmark performance. MiMo-V2-Pro, tested under the codename "Hunter Alpha," broke the 1 trillion token usage mark during internal testing. MiMo-V2-Omni, codenamed "Healer Alpha," dominated the PinchBench leaderboard across audio, video, and vision tasks.

Unlike traditional app-bound AI integrations, Xiaomi built the entire MiMo-V2 series as a browser-based architecture, making it globally accessible without geographical restrictions. Developers worldwide can explore the models immediately via the official MiMo platform or Xiaomi MiMo Studio.

MiMo-V2-Pro: The Heavy-Duty Reasoning Agent

MiMo-V2-Pro is Xiaomi's flagship model designed for high-intensity, complex workflows — the kind that require deep logical reasoning and multi-step task planning with minimal human intervention.

Technical Specifications

MiMo-V2-Pro boasts a 1 Trillion (1T) total parameters with 42 Billion (42B) activated during inference. It utilizes an innovative mixed-attention architecture that supports an ultra-long context window of 1M tokens (1,048,576 tokens to be precise), with a maximum output of 32,000 tokens.

This massive context window means developers can feed the model entire codebases, lengthy document sets, or comprehensive research archives in a single context window — a capability that opens the door to genuinely autonomous coding agents and research assistants.

Benchmark Performance

Tested under the codename "Hunter Alpha" on OpenRouter before Xiaomi's official announcement, MiMo-V2-Pro posted results that turned heads across the AI community:

Benchmark	MiMo-V2-Pro Score	Global Rank
Claw-Eval (average)	75.7	Top 3 globally
Artificial Analysis Intelligence Index	49	2nd in China, 8th globally

On the Claw-Eval benchmark — one of the most rigorous agentic evaluation frameworks — MiMo-V2-Pro placed comfortably in the top three globally, directly trailing Anthropic's Claude Opus 4.6. In the Artificial Analysis Intelligence Index, it surpassed competitors like Grok 4.20 and Gemini 3 Flash, ranking second in China and eighth globally.

Real-World Coding Capabilities

Internal engineering reviews indicate that MiMo-V2-Pro's coding capabilities — encompassing system design, workflow orchestration, and elegant code generation — feel remarkably close to Claude Opus 4.6, but at a fraction of the API cost. This is particularly relevant for developers building:

Autonomous coding agents
Multi-step workflow orchestration systems
Complex system design assistants
Code review and refactoring tools

The model's tool-call capabilities and multi-step reasoning have been fine-tuned via SFT (Supervised Fine-Tuning) and RL (Reinforcement Learning) across diverse, complex agent scaffolds.

MiMo-V2-Omni: The Full-Modality Multimodal Base

MiMo-V2-Omni is Xiaomi's answer to seamless cross-modality understanding. Unlike models that handle modalities separately, MiMo-V2-Omni natively processes image, video, audio, and text inputs as a unified foundation for building agentic systems.

Benchmark Dominance

Under the codename "Healer Alpha," MiMo-V2-Omni dominated the PinchBench leaderboard — a comprehensive multimodal evaluation suite — outperforming heavy hitters like Gemini 3 Pro and Claude Opus 4.6 in several key areas:

Benchmark	MiMo-V2-Omni Score	Notes
BigBench Audio (Speech Reasoning)	94.0	Leads all competing models
MMAU-Pro (Audio Understanding)	69.4	Tops the audio leaderboard
FutureOmni (Video Future Event Forecast)	66.7	Leads the video category

Real-World Capabilities

What sets MiMo-V2-Omni apart isn't just benchmark numbers — it's the depth of understanding across modalities:

Audio understanding goes well beyond transcription into environmental sound classification, multi-speaker disentanglement, and deep comprehension of continuous audio exceeding 10 hours in length
Audio-visual joint reasoning enables the model to reason about content where sound and vision intersect — think video understanding that accounts for dialogue, background music, ambient sounds, and visual elements simultaneously
Autonomous plan development and execution across different modalities, with real-time policy remediation when anomalies are encountered

The model supports a context window of 262K tokens with a maximum output of 32,000 tokens.

Why the "Full-Modality" Approach Matters

Most multimodal models process each modality through separate pipelines that are stitched together. MiMo-V2-Omni takes a fundamentally different approach — building a single unified representation that treats image, video, audio, and text as first-class citizens of the same learning framework. This architecture is what enables the kind of deep cross-modal reasoning that produces those benchmark numbers.

MiMo-V2-TTS: Giving the Agent a Soul

No agent is complete without a voice. MiMo-V2-TTS is Xiaomi's state-of-the-art text-to-speech synthesis model, built on a self-developed Audio Tokenizer and multi-codebook joint modeling architecture.

Training and Quality

The model was trained on hundreds of millions of hours of audio data and refined via multi-dimensional reinforcement learning. This scale of training data is extraordinary — it means the model has been exposed to an almost incomprehensibly diverse range of speech patterns, acoustic environments, and speaking styles.

Emotional and Prosodic Control

Where MiMo-V2-TTS truly stands out is its precise, multi-granular emotional control capabilities:

Emotion and tone transitions mid-sentence — the model can shift from neutral to enthusiastic, or from professional to empathetic, within a single utterance
Accurate pitch control for singing — rare among TTS systems, which typically produce flat, robotic singing voices
Native dialect synthesis including Sichuanese, Henan dialect, Cantonese, and Taiwanese accents — critical for serving Chinese-speaking populations authentically

This combination of emotional granularity, prosodic control, and dialect diversity makes MiMo-V2-TTS a compelling choice for:

Conversational AI agents that need to express empathy and personality
Content creation tools requiring natural-sounding narration
Accessibility applications serving diverse linguistic communities
Interactive entertainment and gaming applications

The Role of TTS in the Agent Era

Xiaomi's decision to release a dedicated TTS model alongside its reasoning and multimodal models is deliberate. In the "Agent Era," AI systems don't just process information — they interact with humans in real-time. A flat, robotic voice immediately breaks the illusion of agency and intelligence. MiMo-V2-TTS is Xiaomi's answer to making agents feel genuinely present and responsive.

API Pricing and Platform Availability

Xiaomi has made the MiMo-V2 series available immediately via platform.xiaomimimo.com, with pricing structured competitively against established frontier models:

MiMo-V2-Pro Pricing

Context Window	Input Price	Output Price
Up to 256K tokens	$1.00 / 1M tokens	$3.00 / 1M tokens
Up to 1M tokens	$2.00 / 1M tokens	$6.00 / 1M tokens

MiMo-V2-Omni Pricing

Context Window	Input Price	Output Price
Up to 256K tokens	$0.40 / 1M tokens	$2.00 / 1M tokens

💡 Pro Tip: The MiMo-V2-Omni pricing at $0.40/1M input tokens makes it one of the most cost-effective multimodal models available at its performance tier.

Free Access

For a limited time, developers can test these models free for one week through popular agent frameworks including:

OpenClaw
OpenCode
KiloCode
Blackbox
Cline

Native Ecosystem Integrations

Certain native integrations — including Xiaomi Browser, Kingsoft Office (Word, Excel, PPT, PDF), and Xiaomi MiMo Studio — are currently targeted at the Chinese market. However, the core API is globally accessible through the browser-based architecture.

How to Access MiMo-V2 Models

Getting started with the MiMo-V2 series is straightforward:

Visit the official platform: https://mimo.xiaomi.com/
Use MiMo Studio: https://aistudio.xiaomimimo.com/ — a browser-based interface for exploring all three models
Integrate via API: Access through your preferred agent framework (OpenClaw, OpenCode, KiloCode, Blackbox, or Cline) for programmatic use
Check platform pricing: https://platform.xiaomimimo.com/

🤔 FAQ

What is MiMo-V2-Pro best used for?

MiMo-V2-Pro excels at complex, multi-step reasoning tasks that require tool use, code generation, system design, and workflow orchestration. It's optimized for building autonomous agents that can handle nuanced, multi-turn tasks with minimal human intervention. With a 1M token context window, it's particularly strong for analyzing entire codebases, large document sets, or comprehensive research archives in a single pass.

How does MiMo-V2-Pro compare to Claude Opus 4.6?

On the Claw-Eval benchmark, MiMo-V2-Pro scores 75.7 (top 3 globally), trailing only Claude Opus 4.6. Internal engineering reviews suggest its coding capabilities feel remarkably close to Claude Opus 4.6, while the API cost is approximately 20% of comparable frontier model pricing.

What makes MiMo-V2-Omni different from other multimodal models?

MiMo-V2-Omni uses a unified architecture that natively processes image, video, audio, and text — rather than stitching together separate pipelines. This approach enables genuinely deep cross-modal reasoning. Its benchmark scores of 94.0 on BigBench Audio, 69.4 on MMAU-Pro, and 66.7 on FutureOmni represent leadership across every perceptual modality tested.

What dialects can MiMo-V2-TTS synthesize?

MiMo-V2-TTS natively supports multiple Chinese regional dialects including Sichuanese, Henan dialect, Cantonese, and Taiwanese accents, in addition to standard Mandarin. It also supports accurate pitch control for singing and multi-granular emotional transitions within single utterances.

Is MiMo-V2 free to use?

Xiaomi offers a one-week free trial for all three models through OpenClaw, OpenCode, KiloCode, Blackbox, and Cline. After the trial period, pricing is available at platform.xiaomimimo.com. MiMo-V2-Omni is particularly competitive at $0.40/1M input tokens.

What is Xiaomi's "Agent Era" strategy?

Xiaomi's "Agent Era" refers to a vision where AI systems autonomously execute complex, multi-step tasks across modalities without requiring constant human guidance. The MiMo-V2 series — with Pro for reasoning, Omni for perception, and TTS for communication — represents the foundational technology stack for this strategy.

Summary & Recommendations

Xiaomi's MiMo-V2 series launch on March 18, 2026 marks one of the most significant AI releases from any Chinese tech company in recent memory. Three models, each purpose-built for a different dimension of the agentic AI stack:

MiMo-V2-Pro brings Claude Opus 4.6-level reasoning capability at a fraction of the cost, with a 1M token context window that makes it viable for entire-codebase analysis and autonomous coding agents
MiMo-V2-Omni sets new benchmarks across every perceptual modality — audio, video, vision, and their intersections — making it a compelling foundation for multimodal agents
MiMo-V2-TTS delivers the emotional and prosodic fidelity needed to make agents feel genuinely present, with rare capabilities like dialect synthesis and singing

For developers and businesses evaluating AI infrastructure in 2026, the MiMo-V2 series deserves serious evaluation — particularly given the aggressive pricing and the one-week free trial available now.

Get started at: https://mimo.xiaomi.com/

This article was generated based on official Xiaomi announcements and benchmark data published on March 18, 2026.

Originally published at: MiMo-V2 Series Complete Guide 2026

MiroThinker-1.7: The New SOTA Open-Source AI Research Agent Revolutionizing Deep Research

cz — Tue, 17 Mar 2026 13:16:35 +0000

MiroThinker-1.7: The New SOTA Open-Source AI Research Agent Revolutionizing Deep Research

🎯 Key Takeaways (TL;DR)

MiroThinker-1.7 achieves state-of-the-art performance among open-source models on deep research benchmarks, scoring 74.0% on BrowseComp and 75.3% on BrowseComp-ZH
The model supports a massive 256K context window with up to 300 tool calls per task, making it ideal for complex long-chain research workflows
Available in two parameter scales (30B and 235B), MiroThinker-1.7 democratizes access to enterprise-grade research agents for developers with varying compute budgets
The underlying "Effective Interaction Scaling" paradigm represents a fundamental shift from simply increasing model size to improving reasoning reliability through verification-centric design

What is MiroThinker-1.7?
Key Features and Capabilities
Performance Benchmarks
Effective Interaction Scaling: The Paradigm Shift
Model Variants and Technical Specifications
Local Deployment Guide
Use Cases and Applications
Comparison with Alternatives
FAQ
Summary and Recommendations

What is MiroThinker-1.7?

MiroThinker-1.7 is a deep research agent optimized for complex research and prediction tasks, developed by MiroMind AI. Released in March 2026, this model family represents a significant leap in building reliable agents for long-chain tasks, achieving SOTA (State-of-the-Art) performance in deep research tasks among open-source models.

MiroThinker-1.7 is specifically designed for agentic workflows—systems that can autonomously navigate the web, gather information, verify facts, and produce comprehensive research outputs. The model builds upon the Qwen3-235B-A22B-Thinking base model and undergoes an enhanced post-training pipeline specifically designed for tool-augmented reasoning.

The development of MiroThinker-1.7 introduces a revolutionary concept called "Effective Interaction Scaling"—a paradigm that improves the quality and reliability of every reasoning step rather than blindly increasing the number of steps or model parameters. This approach marks a fundamental shift in AI research agent design, moving beyond the brute-force scaling of compute towards more intelligent and verifiable reasoning processes.

Key Features and Capabilities

MiroThinker-1.7 comes packed with features that make it stand out in the crowded AI research agent space:

Massive Context Window

The model supports a 256K context window, allowing it to process and retain information from extremely long documents, multiple research papers, or extensive web content. This is particularly valuable for comprehensive literature reviews and multi-source research tasks.

High Tool Call Capacity

Unlike most AI models that can make only a handful of tool calls per conversation, MiroThinker-1.7 can handle up to 300 tool calls per task. MiroThinker-1.7 enables truly autonomous research workflows that can:

Browse multiple web pages
Extract and synthesize information from diverse sources
Cross-reference facts across different documents
Conduct multi-round research iterations

MiroThinker-1.7 also excels at tool orchestration, deciding when to call external tools and how to integrate the results into its reasoning chain.

Enhanced Stepwise Reasoning

The post-training pipeline specifically targets improved stepwise reasoning and decision-making. The model doesn't just generate responses—it thinks through problems methodically, verifying each conclusion before proceeding to the next step.

Flexible Deployment Options

MiroThinker-1.7 is released in two parameter scales to accommodate different use cases and compute budgets:

MiroThinker-1.7-mini: 30B parameters - suitable for developers with limited GPU resources
MiroThinker-1.7: 235B parameters - for maximum performance and research quality

Comprehensive Tool Suite

The model comes with a complete suite of tools and workflows that support diverse research settings, making it adaptable to various domains including academic research, market analysis, competitive intelligence, and technical documentation.

Performance Benchmarks

MiroThinker-1.7 demonstrates exceptional performance across multiple research-focused benchmarks:

Benchmark	Score	Description
BrowseComp	74.0%	Complex web research and information retrieval
BrowseComp-ZH	75.3%	Chinese language web research
GAIA-Val-165	82.7%	General AI assistant assessment
HLE-Text	42.9%	Human-like language evaluation

Notably, MiroThinker-1.7 achieves SOTA performance on BrowseComp-ZH, making it particularly powerful for multilingual research tasks. The model also excels in specialized tasks such as long-form report generation, achieving the highest reported quality score for producing detailed and precise outputs in complex scenarios.

The flagship system built on MiroThinker-1.7, called MiroThinker-H1, further extends these capabilities and achieves an impressive 88.2% on BrowseComp, representing the cutting edge of open-source research agent performance.

Effective Interaction Scaling: The Paradigm Shift

The most innovative aspect of MiroThinker-1.7 is its introduction of "Effective Interaction Scaling"—a fundamentally different approach to improving AI reasoning capabilities. This paradigm is core to how MiroThinker-1.7 achieves superior performance compared to traditional approaches.

Traditional Approach vs. Effective Interaction Scaling

Traditional Approach:

Scale model size (more parameters)
Increase training compute
Add more reasoning steps
Problem: Diminishing returns, increased computational costs, and potential for errors to compound over longer reasoning chains

Effective Interaction Scaling (MiroThinker-1.7):

Focus on improving the quality of each reasoning step
Implement verification-centric design
Ensure every conclusion is validated before proceeding
Result: More reliable outputs with fewer computational resources

MiroThinker-1.7's approach ensures that each step in the research process is verified for accuracy before proceeding to the next step.

This paradigm shift is particularly important for research applications where accuracy and factuality are paramount. Instead of making the model "think longer," MiroThinker-1.7 is designed to "think better"—verifying each step of its reasoning process to produce more trustworthy results.

Verification-Centric Architecture

MiroThinker-H1, the flagship system built on MiroThinker-1.7, provides promising evidence for what MiroMind calls "long-chain verifiable reasoning"—reasoning processes that are both step-verifiable and globally verifiable. This represents a significant advancement for complex agentic workflows where errors can propagate and compound across long research chains.

Model Variants and Technical Specifications

MiroThinker-1.7 is available in multiple configurations to serve different use cases:

Model Name	Parameters	Max Context	Max Tool Calls	Best For
MiroThinker-1.7-mini	30B	256K	300	Development, prototyping, limited GPU setups
MiroThinker-1.7	235B	256K	300	Maximum research quality, enterprise deployments

Technical Details

Base Model: Qwen3-235B-A22B-Thinking-2507
License: Apache 2.0 (fully open-source)
Context Length: 262,144 tokens (max)
Recommended Inference Parameters:
- Temperature: 1.0
- Top P: 0.95
- Repetition Penalty: 1.05
- Max Model Len: 262,144
- Max Tokens: 16,384

Available Quantizations

For local deployment on consumer hardware, the model supports various quantization formats compatible with:

llama.cpp
LM Studio
Jan
Ollama

Local Deployment Guide

Prerequisites

To deploy MiroThinker-1.7 locally, you'll need:

Python environment with necessary dependencies
Sufficient GPU memory (multi-GPU setup recommended for 235B model)
SGLang or vLLM for efficient inference

Deployment Commands

Using SGLang:

python -m sglang.launch_server \
  --model-path miromind-ai/MiroThinker-1.7 \
  --tp 8 \
  --host 0.0.0.0 \
  --port 1234

Using vLLM:

vllm serve miromind-ai/MiroThinker-1.7 \
  --tensor-parallel-size 8 \
  --max-model-len 262144 \
  --enable-reasoning

Online Demo

For those who want to try MiroThinker-1.7 without local deployment, MiroMind offers an online demo at dr.miromind.ai. Note that the demo has limitations (100 tool calls per query) and doesn't support BrowseComp evaluation. To fully leverage MiroThinker-1.7's capabilities, self-hosting is recommended.

Use Cases and Applications

MiroThinker-1.7 is designed for demanding research workflows. Whether you're using MiroThinker-1.7 for academic purposes or commercial applications, the model delivers exceptional results.

Academic Research

Literature review automation
Paper summarization and synthesis
Citation verification

Market Intelligence

Competitive analysis
Industry trend tracking
Company and product research

Technical Documentation

API documentation research
Codebase analysis
Technical specification gathering

Journalism & Content Creation

Fact-checking and verification
Background research
Source compilation

Business Intelligence

Due diligence research
Investment research
Customer and market analysis

MiroThinker-1.7's ability to handle up to 300 tool calls makes it particularly valuable for these use cases.

Comparison with Alternatives

Feature	MiroThinker-1.7	OpenAI DeepResearch	Anthropic Claude (Agent)
Open Source	✅ Yes	❌ No	❌ No
Context Window	256K	200K	200K
Tool Calls/Task	300	~50-100	~50-100
BrowseComp Score	74.0%	~65%*	~60%*
Price	Free (self-hosted)	$200/month	$100/month
Customization	Full	Limited	Limited

*Estimated based on public benchmarks

🤔 FAQ

Q: What makes MiroThinker-1.7 different from other AI models?

A: MiroThinker-1.7 is specifically designed for deep research tasks with tool-augmented workflows. Unlike general-purpose chatbots, it's optimized for long-chain reasoning with up to 300 tool calls per task and 256K context. The "Effective Interaction Scaling" paradigm ensures each reasoning step is verified for accuracy.

Q: Can I use MiroThinker-1.7 for commercial applications?

A: Yes! MiroThinker-1.7 is released under the Apache 2.0 license, which allows for both personal and commercial use.

Q: What hardware do I need to run MiroThinker-1.7?

A: The 235B model requires multi-GPU setup with significant VRAM (approximately 8x A100 or equivalent). For smaller setups, the 30B MiroThinker-1.7-mini offers a more accessible entry point.

Q: How does MiroThinker-1.7 compare to OpenAI's DeepResearch?

A: MiroThinker-1.7 achieves higher BrowseComp scores (74.0% vs ~65%) while being open-source and free to self-host. It's particularly strong in Chinese language research (BrowseComp-ZH: 75.3%).

Q: Is there a free version available?

A: Yes, MiroMind provides an online demo at dr.miromind.ai with limited capabilities (100 tool calls per query). For full capabilities, self-deployment is free under Apache 2.0 license.

Summary & Recommendations

MiroThinker-1.7 represents a breakthrough in open-source AI research agents. With its SOTA performance on deep research benchmarks, massive context window, and high tool call capacity, MiroThinker-1.7 is an excellent choice for:

Researchers who need comprehensive literature reviews and multi-source synthesis - MiroThinker-1.7 excels at gathering and synthesizing information from multiple sources
Developers building autonomous research agents - MiroThinker-1.7 provides the foundation for reliable agentic workflows
Businesses requiring cost-effective market intelligence tools - MiroThinker-1.7 offers enterprise-grade capabilities at open-source pricing
Academics conducting systematic reviews or meta-analyses - MiroThinker-1.7 can handle the complexity of comprehensive research tasks

The "Effective Interaction Scaling" paradigm offers a promising direction for the future of AI reasoning—focusing on quality over quantity in reasoning steps. MiroThinker-1.7 proves that better reasoning quality can outperform sheer computational scale.

Next Steps

Try the demo: Visit dr.miromind.ai to experience MiroThinker-1.7 firsthand
Explore the model: Check out the HuggingFace page for technical details about MiroThinker-1.7
Deploy locally: Follow the deployment guide for self-hosted research capabilities with MiroThinker-1.7
Join the community: Connect with other developers on Discord to discuss MiroThinker-1.7

MiroThinker-1.7 is available under Apache 2.0 license, making it suitable for both personal and commercial applications.

Originally published at: https://curateclick.com/blog/mirothinker-1-7-sota-open-source-ai-research-agent

Originally published at: MiroThinker-1.7: The New SOTA Open-Source AI Research Agent

GLM-5-Turbo Complete Guide 2026

cz — Mon, 16 Mar 2026 13:19:05 +0000

GLM-5-Turbo Complete Guide 2026: China's New Frontier AI Model

🎯 Key Takeaways (TL;DR)

GLM-5-Turbo is Zhipu AI's latest flagship model, designed specifically for high-throughput agentic workloads with improved stability and efficiency
The GLM-5-Turbo model scales to 744B parameters (40B active) with 28.5T training tokens, integrating DeepSeek Sparse Attention for reduced deployment costs
GLM-5-Turbo pricing starts at approximately $0.96 per million input tokens and $3.20 per million output tokens on OpenRouter—significantly undercutting competitors
GLM-5-Turbo is designed for complex agent tasks including advanced reasoning, coding, tool use, web browsing, and multi-step workflows

What is GLM-5-Turbo?
Technical Specifications
Performance and Benchmarks
GLM-5-Turbo vs Competitors
Pricing and Availability
Use Cases
Summary

What is GLM-5-Turbo?

GLM-5-Turbo is the latest flagship large language model from Zhipu AI (also known as Z.ai), a Chinese AI company and the first public AI company in China. Released on February 11, 2026, just days before Lunar New Year, GLM-5 represents a significant leap forward in open-source AI capabilities.

Unlike its predecessors, GLM-5-Turbo is specifically engineered for high-throughput agentic workloads. The "Turbo" variant focuses on improving stability and efficiency in long-chain agent tasks, enabling smoother execution for complex, multi-step workflows.

💡 Pro Tip
GLM-5-Turbo is specifically optimized for OpenClaw and similar agent-driven environments, making it an excellent choice for automation and coding tasks.

Technical Specifications

Specification	GLM-5	GLM-4.5
Total Parameters	744B	355B
Active Parameters	40B	32B
Pre-training Tokens	28.5T	23T
Context Length	Up to 200K	200K
Attention Mechanism	DeepSeek Sparse Attention (DSA)	Standard

Key Technical Innovations

DeepSeek Sparse Attention (DSA): The integration of DSA largely reduces deployment costs while maintaining high performance, making the model more accessible for production use.
Agentic Design: GLM-5 is specifically designed for complex systems engineering and long-horizon agentic tasks, including:
- Advanced reasoning
- Coding and software development
- Tool use and function calling
- Web browsing automation
- Terminal operations
- Multi-step agentic workflows
Extended Context: Supports up to 200K tokens of context, enabling the model to handle long documents and complex conversations without losing track of important details.

Performance and Benchmarks

According to benchmarks and independent testing:

Coding Capabilities: GLM-5 approaches Anthropic's Claude Opus 4.5 in coding benchmark tests
Benchmark Performance: Surpasses Google's Gemini 3 Pro on several benchmarks
Hallucination Rate: Achieves a record-low hallucination rate among open-source models, according to VentureBeat
Agent Stability: Specifically optimized for long-running agent tasks with improved error handling and task continuity

Key Improvements Over GLM-4.5

The model shows significant improvements across multiple dimensions:

Metric	Improvement
Parameter Scale	2x increase (355B → 744B)
Training Data	24% more tokens (23T → 28.5T)
Active Parameters	25% increase (32B → 40B)
Deployment Efficiency	Significantly improved via DSA

GLM-5-Turbo vs Competitors

Pricing Comparison

Model	Input Price (per 1M tokens)	Output Price (per 1M tokens)

Read more at CurateClick

OpenClaw imageModel Configuration Guide 2026

cz — Mon, 09 Mar 2026 03:52:49 +0000

OpenClaw imageModel Configuration Guide 2026

🎯 Key Takeaways (TL;DR)

imageModel is OpenClaw's dedicated configuration for vision understanding, separate from the main conversation model
Configure imageModel to enable "fast text models + capable vision models" for optimal speed and capability
Use CLI commands like openclaw models set-image or edit config directly to manage vision models

What is imageModel
Why Separate Configuration
Configuration Methods
CLI Management Commands
Trigger Scenarios
Fallback Logic
Relationship with pdfModel
Built-in Default Image Models
Complete Configuration Examples

What is imageModel

imageModel is OpenClaw's dedicated model configuration for visual understanding, operating independently from the main conversation model (model). When conversations involve images or visual content, OpenClaw automatically switches to the model specified by imageModel to process the visual input.

This separation allows you to optimize your AI assistant for both speed (using fast text-only models for regular conversations) and capability (using multimodal models when images are involved).

Why Separate Configuration

Your primary model (model.primary) may not support visual input. For example:

MiniMax-M2.5-highspeed is a text-only model and cannot process images
moonshot/kimi-k2.5 supports multimodal (text + images)

Configuring imageModel separately enables you to achieve:

💡 Key Benefit
Text goes through fast models, images go through multimodal models — balancing speed and capability.

This is particularly useful when:

You want to use cost-effective text models for most conversations
You need capable vision models only when processing images
You want to configure fallback chains for vision tasks

Configuration Methods

In your OpenClaw configuration file (edit via openclaw config edit):

{
  "agents": {
    "defaults": {
      "model": {
        "primary": "minimax-portal/MiniMax-M2.5-highspeed",
        "fallbacks": ["moonshot/kimi-k2.5", "anthropic/claude-opus-4-6"]
      },
      "imageModel": {
        "primary": "moonshot/kimi-k2.5",
        "fallbacks": ["openrouter/qwen/qwen-2.5-vl-72b-instruct:free"]
      }
    }
  }
}

Two Syntax Options

Shorthand (primary model only, no fallback):

"imageModel": "moonshot/kimi-k2.5"

Full syntax (primary + fallback chain):

"imageModel": {
  "primary": "moonshot/kimi-k2.5",
  "fallbacks": ["openrouter/google/gemini-2.0-flash-vision:free"]
}

Both formats are supported. The full syntax provides redundancy for vision tasks.

CLI Management Commands

OpenClaw provides convenient CLI commands for managing imageModel:

# View current imageModel status
openclaw models status

# Set imageModel primary model
openclaw models set-image moonshot/kimi-k2.5

# Manage imageModel fallback chain
openclaw models image-fallbacks list
openclaw models image-fallbacks add openrouter/qwen/qwen-2.5-vl-72b-instruct:free
openclaw models image-fallbacks remove openrouter/qwen/qwen-2.5-vl-72b-instruct:free
openclaw models image-fallbacks clear

These commands make it easy to switch vision models without manually editing config files.

Trigger Scenarios

Scenario	Description
User sends images	Photos, screenshots, or image attachments where the agent needs to "see and describe"
User sends PDF	PDFs containing scanned pages/images requiring visual analysis (checks pdfModel first, falls back to imageModel)
Media understanding pipeline	Automatic media understanding when images/video frames are received
Agent tool calls	When agents use the built-in `image` tool to analyze images

⚠️ Important
PDF handling follows this priority: pdfModel → imageModel → built-in provider default. If no pdfModel is configured, it automatically falls back to imageModel.

Fallback Logic

The fallback chain works as follows:

imageModel.primary → imageModel.fallbacks[0] → fallbacks[1] → ...

OpenClaw tries each model sequentially, returning the first successful response. If all models fail, you'll receive this error:

Error: "No image model configured. Set agents.defaults.imageModel.primary or agents.defaults.imageModel.fallbacks."

Relationship with pdfModel

PDF processing follows this priority:

pdfModel → imageModel → built-in provider default

If you don't configure pdfModel, the PDF tool will automatically fall back to the imageModel configuration. This design ensures consistent vision model handling across different file types.

Built-in Default Image Models

When imageModel is not configured and the system detects the corresponding provider's API key, OpenClaw uses built-in defaults:

Provider	Default Model
OpenAI	gpt-5-mini
Anthropic	claude-opus-4-6
Google	gemini-3-flash-preview
MiniMax	MiniMax-VL-01
ZAI	glm-4.6v

These defaults ensure vision capabilities work out of the box when you have API keys configured.

Complete Configuration Examples

Here's a comprehensive configuration example:

{
  "agents": {
    "defaults": {
      "model": {
        "primary": "minimax-portal/MiniMax-M2.5-highspeed",
        "fallbacks": ["moonshot/kimi-k2.5", "anthropic/claude-opus-4-6"]
      },
      "imageModel": {
        "primary": "moonshot/kimi-k2.5",
        "fallbacks": ["openrouter/google/gemini-2.0-flash-vision:free"]
      },
      "pdfModel": {
        "primary": "anthropic/claude-opus-4-6"
      },
      "models": {
        "moonshot/kimi-k2.5": {
          "alias": "kimi"
        },
        "minimax-portal/MiniMax-M2.5-highspeed": {
          "alias": "mm"
        }
      }
    }
  }
}

Expected Behavior

With this configuration:

Text conversations → MiniMax-M2.5-highspeed (fast, text-only)
Sending images → moonshot/kimi-k2.5, fallback to gemini-2.0-flash-vision if it fails
Sending PDFs → claude-opus-4-6, falls back to imageModel chain if not configured

🤔 FAQ

Q: Can I use the same model for both text and images?

A: Yes, if your primary model supports multimodal input (like moonshot/kimi-k2.5 or anthropic/claude-opus-4-6), you can set both model.primary and imageModel.primary to the same value.

Q: What happens if I don't configure imageModel?

A: OpenClaw will use built-in default models based on your configured API providers. However, explicitly configuring imageModel gives you more control over which vision model is used.

Q: How do free vision models work in the fallback chain?

A: Models like openrouter/google/gemini-2.0-flash-vision:free or openrouter/qwen/qwen-2.5-vl-72b-instruct:free are free tier models from OpenRouter. They're useful as fallbacks when your primary vision model fails or is unavailable.

Summary & Recommendations

Configuring imageModel in OpenClaw is essential for:

Cost optimization — Use fast, cheap text models for regular conversations
Capability assurance — Ensure vision tasks always have a capable model
Redundancy — Set up fallback chains to prevent single points of failure

Recommended next steps:

Check your current configuration with openclaw models status
Configure a primary imageModel if you haven't already
Add fallback models for redundancy
Test with image inputs to verify the configuration works

For more details, visit the OpenClaw Documentation.

Originally published at: OpenClaw imageModel Configuration Guide 2026

2026 Complete Guide: Top Text-to-Video Models on HuggingFace

cz — Sun, 08 Mar 2026 02:24:17 +0000

🎯 Key Takeaways (TL;DR)

The text-to-video AI landscape is evolving rapidly, with open-source models now challenging commercial solutions like Runway and Luma
Wan2.2 series and Tencents HunyuanVideo dominate the latest releases, offering consumer-friendly options that run on single GPUs like RTX 4090
GGUF quantization is making large video models accessible on lower-end hardware, reducing VRAM requirements from 60GB+ to under 10GB

Introduction: The Text-to-Video Revolution
Model 1: Wan2.2-TI2V-5B
Model 2: HunyuanVideo
Model 3: Wan2.2-T2V-A14B-GGUF
Model 4: I2VGen-XL
Comparison Analysis
FAQ
Summary & Recommendations

Introduction: The Text-to-Video Revolution {#introduction}

Text-to-video generation has undergone a remarkable transformation in 2025-2026. What was once the exclusive domain of well-funded AI labs is now accessible to developers and creators through open-source platforms like HuggingFace. The latest wave of models brings unprecedented quality, with several open-source releases now matching or exceeding commercial alternatives in specific benchmarks.

This article examines the five most significant text-to-video models released on HuggingFace within the past five days, analyzing their capabilities, strengths, limitations, and practical applications.

Model 1: Wan2.2-TI2V-5B {#model1}

Overview

Wan2.2-TI2V-5B represents a significant advancement in the Wan video generation family. Developed by Wan-AI and uploaded by community member SriCarlo, this 5-billion parameter model specializes in Text-to-Image-to-Video (TI2V) generation, supporting both pure text prompts and image-to-video workflows.

Key Features

Dual Capability: Supports both text-to-video (T2V) and image-to-video (I2V) generation in a unified framework
High Resolution: Generates 720P videos at 24fps
Consumer GPU Friendly: Runs on a single RTX 4090 with ~24GB VRAM
MoE Architecture: Implements Mixture-of-Experts design for efficient inference
High Compression VAE: Uses Wan2.2-VAE achieving 16×16×4 compression ratio

Technical Details

The model leverages a sophisticated VAE (Variational Autoencoder) that compresses video by a factor of 64, dramatically reducing computational requirements while maintaining visual quality. The MoE architecture separates denoising processes across timesteps, with specialized expert models handling high-noise (early denoising) and low-noise (detail refinement) stages.

Pros

✅ Runs on consumer-grade hardware (RTX 4090)
✅ Apache 2.0 license for commercial use
✅ Supports both English and Chinese
✅ Integrates with Diffusers and ComfyUI
✅ Fast inference: under 9 minutes for 5-second 720P video

Cons

❌ Lower parameter count may limit complex motion generation
❌ Community upload (not official Wan-AI release)
❌ Limited to 5-second clips in standard mode

Best Use Cases

Content creators needing quick video prototypes
Social media content generation
Educational video creation
Product demonstration clips

Model 2: HunyuanVideo {#model2}

Overview

HunyuanVideo, uploaded by Khanbby, is Tencents official open-source text-to-video foundation model with 13 billion parameters. According to professional human evaluations, it outperforms industry leaders including Runway Gen-3, Luma 1.6, and top Chinese video generation platforms.

Key Features

13B Parameters: Largest open-source video model at release
MLLM Text Encoder: Uses Multimodal Large Language Model for superior prompt understanding
3D VAE: Spatio-temporally compressed latent space (4×8×16 compression)
Dual-Stream Architecture: "Dual-stream to Single-stream" design for effective multimodal fusion
Prompt Rewrite: Built-in system to optimize user prompts for better results

Technical Details

HunyuanVideo employs a revolutionary text encoding approach. Unlike traditional models using CLIP or T5, it leverages a Multimodal LLM that has undergone visual instruction fine-tuning, resulting in better image-text alignment and complex reasoning capabilities. The model also includes a bidirectional token refiner to enhance text guidance—a technique borrowed from causal attention architectures.

Performance Benchmarks

Metric	HunyuanVideo	Runway Gen-3	Luma 1.6
Text Alignment	61.8%	47.7%	57.6%
Motion Quality	66.5%	54.7%	44.2%
Visual Quality	95.7%	97.5%	94.1%
Overall Ranking	#1	#4	#5

Pros

✅ Best-in-class motion quality among open-source models
✅ Superior text prompt understanding
✅ Professional human evaluation proves competitive with commercial options
✅ FP8 quantization available (saves ~10GB GPU memory)
✅ Supports parallel inference via xDiT

Cons

❌ Requires 60-80GB GPU memory for 720P
❌ Not truly open license (Tencent Hunyuan Community License)
❌ Complex setup requiring CUDA 11.8 or 12.4
❌ Linux-only officially

Best Use Cases

High-quality commercial video production
Film and advertising pre-visualization
Complex narrative video generation
Research and academic purposes

Model 3: Wan2.2-T2V-A14B-GGUF {#model3}

Overview

Wan2.2-T2V-A14B-GGUF by user Y1998 is a quantized version of the Wan2.2 14B parameter model, converted to GGUF format for efficient inference. This model demonstrates the growing trend of making large video models accessible through quantization.

Key Features

14B Parameters: Full Wan2.2 MoE model in quantized format
Multiple Quantization Levels: From Q2_K (5.3GB) to Q8_0 (15.4GB)
ComfyUI Integration: Works seamlessly with ComfyUI-GGUF
Consumer Hardware Accessible: Q4_K variants run on 8-10GB GPUs

Quantization Options

Format	File Size	VRAM Required	Quality
Q2_K	5.3 GB	~6 GB	Lowest
Q3_K_S	6.51 GB	~7 GB	Low
Q4_K_S	8.75 GB	~9 GB	Medium
Q4_K_M	9.65 GB	~10 GB	Medium
Q5_K_M	10.8 GB	~11 GB	High
Q6_K	12 GB	~13 GB	Higher
Q8_0	15.4 GB	~16 GB	Highest

Pros

✅ Dramatically reduces hardware requirements
✅ Multiple quality/size tradeoffs available
✅ Apache 2.0 license preserved from original
✅ Easy deployment via ComfyUI

Cons

❌ Quantization may introduce artifacts
❌ Not as performant as full FP16 models
❌ Requires ComfyUI knowledge
❌ Community conversion (unofficial)

Best Use Cases

Users with limited GPU resources
Quick prototyping and testing
Low-memory workstations
Educational exploration of video generation

Model 4: I2VGen-XL {#model4}

Overview

I2VGen-XL (uploaded by isfs) is Alibabas image-to-video generation model, part of the VGen codebase. Unlike pure text-to-video models, I2VGen-XL specializes in transforming static images into dynamic videos—a crucial capability for many creative workflows.

Key Features

Cascaded Diffusion Models: Two-stage approach for high-quality output
Image-to-Video Focus: Excels at animating still images
1280×720 Resolution: High-definition video output
MIT License: Truly open for commercial use
Diffusers Integration: Native support in HuggingFace Diffusers

Technical Approach

I2VGen-XL employs a cascaded generation strategy. The first stage creates an initial video with basic motion, while the second stage refines details and enhances visual quality. This approach allows the model to maintain image identity while generating realistic motion.

Pros

✅ MIT license (most permissive)
✅ Strong image-to-video quality
✅ Well-documented with multiple papers
✅ Active development since 2023

Cons

❌ Requires starting image (not pure T2V)
❌ Limited to ~16 frames in some configurations
❌ Performance drops on anime and black-background images
❌ Research/non-commercial restrictions in training data

Best Use Cases

Photo animation and revival
Product showcase videos
Art-to-video transformation
Legacy photo enhancement

Comparison Analysis {#comparison}

Feature-by-Feature Comparison

Feature	Wan2.2-TI2V-5B	HunyuanVideo	Wan2.2-GGUF	I2VGen-XL
Parameters	5B	13B	14B (quantized)	~6B
Type	T2V+I2V	T2V	T2V	I2V
Resolution	720P	720P	720P	720P
Min VRAM	24GB	60GB	6GB	16GB
License	Apache 2.0	Tencent	Apache 2.0	MIT
Official	Community	Yes	Community	Yes
ComfyUI	Yes	Limited	Yes	Limited

Hardware Requirements Summary

User Scenario	Recommended Model
RTX 4090/3090 (24GB)	Wan2.2-TI2V-5B
A100 (40GB)	Wan2.2-TI2V-5B, I2VGen-XL
A100 (80GB)	HunyuanVideo
Consumer GPU (<12GB)	Wan2.2-GGUF (Q4-Q5)
Professional Studio	HunyuanVideo

FAQ {#faq}

Q: Which text-to-video model is best for beginners?

A: For beginners, Wan2.2-TI2V-5B offers the best balance of ease-of-use and quality. It runs on consumer hardware, has excellent documentation, and supports both text and image inputs. The Apache 2.0 license also means you can use it commercially without concerns.

Q: Can I use these models commercially?

A: Most models allow commercial use with some restrictions:

Wan2.2 series: Apache 2.0 → Fully commercial
HunyuanVideo: Tencent License → Check terms
I2VGen-XL: MIT → Fully commercial
Always verify the specific license for your use case

Q: How do I run these models without a GPU?

A: Currently, running text-to-video models requires a GPU. However, HuggingFace Inference Providers offer API access. Check the models page for available inference endpoints, or consider cloud services like RunPod, Paperspace, or Lambda Labs for temporary GPU access.

Q: Whats the difference between text-to-video and image-to-video?

A: Text-to-video (T2V) generates videos entirely from text descriptions. Image-to-video (I2V) takes a static image as input and animates it. Some models like Wan2.2 support both (TI2V). I2V is generally easier as it preserves the structure from the input image.

Q: How long does video generation take?

A: Generation time varies significantly:

Wan2.2-TI2V-5B: ~5-9 minutes for 5 seconds
HunyuanVideo: ~10-15 minutes for 5 seconds (720P)
GGUF models: Slower due to quantization overhead
With 8-GPU parallel: Can reduce to ~3-5 minutes

Summary & Recommendations {#summary}

The text-to-video ecosystem on HuggingFace is reaching a maturity point where open-source models can genuinely compete with commercial alternatives. Here are our recommendations:

For Content Creators

Start with Wan2.2-TI2V-5B if you have an RTX 4090 or similar GPU. It offers the best balance of quality, speed, and accessibility.

For High-Quality Production

If you need the best possible motion quality and have access to A100s or H100s, HunyuanVideo delivers professional results that rival or exceed commercial tools.

For Limited Hardware

Wan2.2-T2V-A14B-GGUF (Q4_K quantization) makes 14B parameter video generation possible on GPUs with just 8-10GB of VRAM.

For Image Animation

I2VGen-XL remains the top choice when you need to animate existing images with MIT licensing for full commercial freedom.

The video generation landscape continues evolving rapidly. Bookmark this page—well update it as new models emerge and existing ones improve.

Originally published at: 2026 Complete Guide: Top Text-to-Video Models on HuggingFace

2026 Complete Guide: OpenClaw ACP - Bridge Your IDE to AI Agents

cz — Wed, 04 Mar 2026 11:56:51 +0000

2026 Complete Guide: OpenClaw ACP - Bridge Your IDE to AI Agents

🎯 Key Takeaways (TL;DR)

OpenClaw ACP (Agent Client Protocol) is a bridge that connects your IDE directly to an OpenClaw Gateway session, enabling AI agents to drive development workflows from your editor
The OpenClaw ACP bridge maintains session continuity, allowing you to reconnect to the same conversation transcript or start fresh sessions on demand
Setting up OpenClaw ACP takes less than 5 minutes and works with popular editors like Zed, with support for custom IDE integrations

What is OpenClaw ACP?
How the OpenClaw ACP Bridge Works
Installation and Setup
Connecting to Remote Gateways
Session Management Deep Dive
Zed Editor Integration
Security Best Practices
FAQ
Summary & Recommendations

What is OpenClaw ACP?

OpenClaw ACP is a command-line tool that implements the Agent Client Protocol (ACP), serving as a bridge between your IDE and an OpenClaw Gateway instance. Think of it as a communication tunnel that allows your code editor to send prompts directly to an AI agent and receive responses back—all without leaving your development environment.

The OpenClaw ACP bridge speaks ACP over stdio (standard input/output), making it compatible with any IDE or tooling that supports the protocol. It forwards prompts to the OpenClaw Gateway over WebSocket and maintains session mappings, so your AI conversations persist across editor restarts.

Why Use OpenClaw ACP?

Traditional AI coding assistants often work in isolation—you paste code, get a response, and start over. OpenClaw ACP changes this by:

Maintaining Context: Your OpenClaw ACP agent remembers previous conversations, decisions, and code changes
Enabling Persistent Workflows: Work on a feature across multiple OpenClaw ACP sessions without losing progress
Integrating Natively: No need to copy-paste between chat interfaces and your IDE
Supporting Multiple Agents: Route different tasks to different specialized agents via OpenClaw ACP session keys

How the OpenClaw ACP Bridge Works

At its core, the OpenClaw ACP bridge performs three critical functions:

1. Protocol Translation

The OpenClaw ACP bridge translates between ACP (used by IDEs) and OpenClaw's internal Gateway protocol (WebSocket-based). This allows any ACP-compatible client to interact with OpenClaw agents seamlessly.

2. Session Management

Each OpenClaw ACP session maps to a single Gateway session key. The OpenClaw ACP bridge maintains this mapping, enabling:

Reconnection to existing OpenClaw ACP sessions
Session reset when needed
Label-based session resolution

3. Authentication Handling

The OpenClaw ACP bridge manages authentication with the Gateway, supporting multiple methods:

Token-based authentication
Password-based authentication
Token/password file reading for enhanced security

Installation and Setup

Prerequisites

Before setting up OpenClaw ACP, ensure you have:

OpenClaw installed on your system
A running Gateway instance (local or remote)
An ACP-compatible IDE (like Zed)

Basic Local Setup

For a local Gateway, the setup is straightforward:

openclaw acp

This starts the OpenClaw ACP bridge using your local Gateway configuration. The OpenClaw ACP bridge will listen for ACP messages over stdio.

Verifying Your Setup

You can test the OpenClaw ACP bridge without an IDE using the built-in ACP client:

openclaw acp client

This spawns an interactive OpenClaw ACP session where you can type prompts directly. It's perfect for debugging or quick experiments.

Connecting to Remote Gateways

One of ACP's most powerful features is its ability to connect to remote Gateway instances—enabling teams to share agent resources or work with cloud-hosted AI assistants.

Using URL and Token

openclaw acp --url wss://gateway-host:18789 --token <your-token>

Using Token File (More Secure)

openclaw acp --url wss://gateway-host:18789 --token-file ~/.openclaw/gateway.token

💡 Pro Tip
Always prefer --token-file over --token to avoid exposing credentials in process listings or shell history.

Persisting Remote Configuration

If you frequently connect to a remote Gateway, save the configuration:

openclaw config set gateway.remote.url wss://gateway-host:18789
openclaw config set gateway.remote.token <your-token>

Then simply run:

openclaw acp

Session Management Deep Dive

Understanding session management is crucial for leveraging OpenClaw ACP effectively.

Default Behavior

By default, each OpenClaw ACP session gets an isolated Gateway session key with an acp: prefix. This means:

New OpenClaw ACP connections start fresh
No session history is shared between connections
You can have multiple independent OpenClaw ACP sessions simultaneously

Targeting Specific Sessions

Use the --session flag to connect to existing OpenClaw ACP sessions:

# Connect to main agent session
openclaw acp --session agent:main:main

# Connect to design agent
openclaw acp --session agent:design:main

# Connect to a specific bug fix session
openclaw acp --session agent:qa:bug-123

Session Labels

For more readable session references, use labels:

openclaw acp --session-label "support inbox"

Resetting Sessions

Need a fresh start without losing your session key? Use --reset-session:

openclaw acp --session agent:main:main --reset-session

This creates a new OpenClaw ACP transcript while keeping the same session identifier.

Advanced: Metadata Overrides

If your ACP client supports metadata, you can override OpenClaw ACP session settings per-request:

{
  "_meta": {
    "sessionKey": "agent:main:main",
    "sessionLabel": "support inbox",
    "resetSession": true
  }
}

Zed Editor Integration

Zed editor provides first-class support for ACP agents. Here's how to set it up:

Basic Configuration

Add this to your ~/.config/zed/settings.json:

{
  "agent_servers": {
    "OpenClaw ACP": {
      "type": "custom",
      "command": "openclaw",
      "args": ["acp"],
      "env": {}
    }
  }
}

Connecting to a Specific Gateway

For remote or specific agent targeting:

{
  "agent_servers": {
    "OpenClaw ACP": {
      "type": "custom",
      "command": "openclaw",
      "args": [
        "acp",
        "--url",
        "wss://gateway-host:18789",
        "--token",
        "<token>",
        "--session",
        "agent:design:main"
      ],
      "env": {}
    }
  }
}

Once configured, open the Agent panel in Zed and select "OpenClaw ACP" to start a thread.

Security Best Practices

When using ACP, security should be a top priority:

1. Prefer File-Based Credentials

# Instead of
openclaw acp --token my-secret-token

# Use
openclaw acp --token-file ~/.openclaw/gateway.token

2. Environment Variables

You can also use environment variables for authentication:

export OPENCLAW_GATEWAY_TOKEN=your-token
openclaw acp --url wss://gateway-host:18789

3. Shell-Specific Rules

ACP sets OPENCLAW_SHELL=acp for runtime backend processes. You can use this in your shell profile to apply context-specific rules:

if [ "$OPENCLAW_SHELL" = "acp" ]; then
    # Apply restricted settings for ACP sessions
    set -e
fi

4. Client Debug Mode Permissions

When using openclaw acp client for testing:

Auto-approval only applies to trusted core tool IDs
Read operations are scoped to the current working directory
Unknown tools and dangerous operations always require explicit approval

🤔 FAQ

Q: Do I need to install anything extra for OpenClaw ACP?

A: No. OpenClaw ACP comes bundled with OpenClaw. Just ensure you have OpenClaw installed and a Gateway running.

Q: Can I use OpenClaw ACP with VS Code or JetBrains IDEs?

A: OpenClaw ACP requires an IDE that supports the Agent Client Protocol. Zed has native support. For other IDEs, you may need to use the OpenClaw ACP bridge with a plugin or extension that supports custom agent servers.

Q: What happens if my Gateway goes offline?

A: The OpenClaw ACP bridge will attempt to reconnect. If you're using session persistence, reconnection will restore your conversation context (if supported by your ACP client).

Q: How is OpenClaw ACP different from OpenClaw's built-in agent command?

A: The openclaw agent command starts an interactive session in your terminal. OpenClaw ACP is designed for IDE integration, speaking the standardized ACP protocol over stdio for seamless editor integration.

Q: Can multiple IDE instances connect to the same OpenClaw ACP session?

A: Yes, if they use the same session key. However, this may lead to conflicts if both send prompts simultaneously.

Summary & Recommendations

OpenClaw ACP bridges the gap between your IDE and AI agents, enabling a seamless development workflow where context persists and conversations flow naturally between you and your AI assistant.

Key Recommendations:

Start Local: Begin with a local Gateway to understand the OpenClaw ACP mechanics
Use Session Keys: Leverage OpenClaw ACP session keys to organize different projects or agents
Secure Your Setup: Always prefer token files over inline tokens for OpenClaw ACP
Try Zed: The OpenClaw ACP Zed integration provides the smoothest experience currently
Experiment with Labels: Use OpenClaw ACP session labels for human-readable session management

Next Steps:

Read the official OpenClaw ACP documentation for advanced usage
Explore ACP protocol specification for deeper understanding
Join the OpenClaw community to share OpenClaw ACP workflows and tips

Originally published at: OpenClaw ACP Guide 2026

DEV Community: cz

Qwen3.6-Plus: Alibaba's Quiet Giant in the AI Race Delivers a Million-Token Enterprise Powerhouse

Qwen3.6-Plus: Alibaba's Quiet Giant in the AI Race Delivers a Million-Token Enterprise Powerhouse

🎯 TL;DR

Table of Contents

1. What is Qwen3.6-Plus?

2. The 1-Million-Token Context Window: Why It Matters

3. Agentic Coding: The Real Headline

4. Multimodal Reasoning Across the Alibaba Ecosystem

5. Technical Architecture: Hybrid Design for Efficiency

6. Benchmark Performance

7. Enterprise Use Cases: Where Qwen3.6-Plus Shines

Software Engineering Automation

Customer Service & Support

Financial Analysis & Document Processing

Healthcare & Research

8. How to Access and Integrate Qwen3.6-Plus

9. Qwen3.6-Plus vs. The Competition

10. Frequently Asked Questions

Q: What is Qwen3.6-Plus?

Q: How does Qwen3.6-Plus compare to GPT-4o?

Q: Is Qwen3.6-Plus free to use?

Q: What makes Qwen3.6-Plus different from earlier Qwen models?

Q: Can I self-host Qwen3.6-Plus?

11. Summary & Next Steps

CurateClick Weekly Picks: 6 Fresh Tools Worth Trying (Mar 22, 2026 Edition)

TL;DR

What are Weekly Picks on CurateClick?

1) Dinner Party Practice — the art of having something to say (Mar 22, 2026)

Why it stands out

Notable features

A quick way to use it

2) Pretty Scale — How Pretty Are You? Let AI Decide. (Mar 22, 2026)

What's interesting (and what to be careful about)

Privacy notes

3) C2story — Create Illustrated Stories with AI (Mar 7, 2026)

Why it stands out

Notable features

Practical use cases

4) Random Topic Generator — Impromptu Speech Topics & Timer (Feb 22, 2026)

Why it's useful

A simple training loop (10 minutes/day)

5) Seedance 2.0 — multi-shot cinematic video, no clips (Feb 10, 2026)

Why this matters

How to think about it

6) ValRequest — Turn Feelings Into Words (Feb 6, 2026)

Why it works

Best practice

Want your product featured next?

More Weekly Picks

2026 Complete Guide: OpenClaw LCM Plugin — Never Lose a Single Conversation Again

2026 Complete Guide: OpenClaw LCM Plugin — Never Lose a Single Conversation Again

🎯 Key Takeaways (TL;DR)

Table of Contents

What Problem Does LCM Solve?

Installation Walkthrough

From npm (Recommended)

From a Local Clone (for Development)

Activate as the Context Engine

Verify

Update

How the DAG Model Works

The Core Insight

Lifecycle Hooks

Compaction: Three Escalation Levels

Large File Handling

Configuration Deep Dive

Key Parameters

Session Filtering

Recommended Configurations

Agent Tools: grep, describe, expand_query

lcm_grep — Fast Full-Text Search

lcm_describe — Direct Metadata Lookup

lcm_expand_query — Deep Recall via Sub-Agent

When to Use Each Tool

Architecture Internals

Crash Recovery

Sub-agent Isolation

Advantages Over Traditional Context Management

Nothing Is Lost