ClawsomeFlow documentation

ClawsomeFlow lets you describe a goal, lay it out as a graph of tasks, and have a whole cast of executors carry it out — CLI agents, real people, remote ClawsomeFlow instances, and custom tools of your own — each in isolation, with every step visible to you. It breaks agent collaboration out of the single-machine box, and a durable harness holds long, multi-party work together. This guide walks you through using the product from its web console.

You don't write any glue code. You define Flows in the browser, press Run, watch the agents work live, and approve the result. Everything below is something you can do from the console.

ClawsomeFlow task orchestration overview diagram

⚙️ Install & open the console One command to install, then open ClawsomeFlow in your browser. 🧩 Key concepts Flow, Task, Leader, Agent — the words you'll see in the UI. 🚀 Your first Flow Go from a sentence to a finished, reviewed result. 💡 FAQ Clears up the points people most often misread.

ClawsomeFlow 使用文档

ClawsomeFlow 让你只需描述目标、把它编排成一张任务图，再由各路执行方来完成——CLI Agent、真人、远程 ClawsomeFlow、你自研的工具——彼此隔离，且每一步都对你可见。它让 Agent 协作跳出单机的盒子，并用一套持久的 Harness 把长周期、多方协作稳稳托住。本指南将带你从 Web 控制台开始上手这款产品。

你无需编写任何胶水代码。你在浏览器里定义 Flow，点击运行，实时观看 Agent 工作，并确认最终结果。下文介绍的一切，都可以在控制台中完成。

⚙️ 安装并打开控制台一条命令完成安装，然后在浏览器中打开 ClawsomeFlow。 🧩 核心概念 Flow、任务、Leader、Agent——你会在界面里看到的术语。 🚀 第一个 Flow 从一句话，到一份经过审阅的成果。 💡 常见问题解答澄清大家最常误解的几个地方。

Install & open the console

ClawsomeFlow runs on your own machine (Linux or macOS). Install it with one line:

curl -fsSL https://clawsomeflow.com/install.sh | bash

Start the background service (already running by default):

csflow start

Open the console in your browser — by default that's:

http://localhost:17017

The web console is where you do everything else in this guide. A few commands are handy:

csflow status — check whether the service is running.
csflow stop — stop the service.
csflow doctor — run a health check if something looks off.

ℹ️

ClawsomeFlow drives real agent CLIs (such as OpenClaw, Claude Code, Codex, Gemini CLI…). Install and log in to at least one of them first — those are the "workers" your Flows dispatch tasks to.

安装并打开控制台

ClawsomeFlow 运行在你自己的机器上（Linux 或 macOS）。一行命令即可安装：

curl -fsSL https://clawsomeflow.com/install.sh | bash

启动后台服务（默认已开启）：

csflow start

在浏览器中打开控制台——默认地址为：

http://localhost:17017

本指南后续的所有操作都在 Web 控制台中完成。几个常用命令：

csflow status——查看服务是否在运行。
csflow stop——停止服务。
csflow doctor——遇到异常时做一次健康检查。

ℹ️

ClawsomeFlow 会驱动真实的 Agent CLI（如 OpenClaw、Claude Code、Codex、Gemini CLI 等）。请先安装并登录其中至少一个——它们就是 Flow 派发任务的「工人」。

Key concepts

Five words explain almost the entire interface. Learn these and the rest is obvious.

Flow

A reusable plan: an overall goal plus a graph of tasks. You build and save Flows on the Flow List page, then run them as many times as you like. A Flow is a template; running it creates a Run.

Task

One unit of work inside a Flow, owned by one agent. Tasks can depend on other tasks — a task only starts once everything it depends on is done. Those dependencies form a DAG (a graph with no cycles), which is what lets independent tasks run in parallel.

Leader & the summary task

Every Flow has exactly one Leader. The Leader owns one special task — the summary task — which gathers all the other tasks' outputs, processes them according to your requirements, and delivers the final deliverable back to you. Importantly, the Leader owns only that summary task; it never owns ordinary worker tasks.

Agent & Agent source

An agent is the worker that actually executes a task. Each task picks an agent source — the CLI behind it, e.g. OpenClaw, Claude Code, Codex, Gemini, Cursor, and more. Different tasks in one Flow can use different sources.

Workspace isolation

Every agent works in its own isolated copy of the project (its own folder and git branch). Agents working in parallel never overwrite each other. At the end, their work is merged back together — so nothing lands until it's been brought together deliberately.

For an OpenClaw agent, that workspace is exactly the one it has registered in OpenClaw. Even when it handles several subtasks in parallel, workspace isolation is still strictly guaranteed, and its work is automatically merged back into that workspace once the Flow finishes.

Run

A single execution of a Flow. You can run the same Flow many times; each Run is tracked independently on the Flow Runs page with its own live view and history.

Reusing the same Agent — session & branch boundaries

Within the same Run instance, if different subtasks are assigned to the same Agent, they share one session process and context, and one working branch, but tasks run one after another — preserving continuity of working memory while avoiding concurrent conflicts.
Across different Runs, the same Agent has fully independent session processes and strictly isolated working branches.
Across different Flow templates, the same Agent likewise has fully independent session processes and strictly isolated working branches.

核心概念

五个词几乎就能解释整个界面。理解了它们，其余一目了然。

Flow（流程）

一份可复用的计划：一个总体目标，加上一张任务图。你在 Flow 列表 页面里编排并保存 Flow，然后可以反复运行它。Flow 是模板；运行它会产生一次 Run（执行）。

Task（任务）

Flow 内部的一个工作单元，由一个 Agent 负责。任务之间可以有依赖关系——只有当它依赖的任务全部完成后，该任务才会开始。这些依赖构成一张 DAG（有向无环图），正是它让相互独立的任务得以并行执行。

Leader 与汇总任务

每个 Flow 都有且仅有一个 Leader。Leader 负责一个特殊任务—— 汇总任务——它会收集其他所有任务的产出，按照你的要求处理这些产出，并把最终交付物整理后反馈给你。请特别注意：Leader 只负责这一个汇总任务，不会负责任何普通的工作任务。

Agent 与 Agent 来源

Agent 是真正执行任务的工人。每个任务都要选择一种 Agent 来源—— 即其背后的 CLI，例如 OpenClaw、Claude Code、Codex、Gemini、Cursor 等。同一个 Flow 中，不同任务可以使用不同来源。

工作区隔离

每个 Agent 都在项目的一个独立副本中工作（各自的目录与 git 分支）。并行工作的 Agent 之间绝不会互相覆盖。任务结束后，它们的成果会被合并到一起——所以在被有意识地汇合之前，任何改动都不会真正落地。

对于 OpenClaw Agent 而言，它的工作区就是它在 OpenClaw 中注册的 workspace。即使并行执行多个子任务，也会绝对确保工作区隔离；并且在工作流结束后，它的成果会自动合入该 workspace。

Run（执行）

一个 Flow 的一次运行。同一个 Flow 可以被运行多次；每次 Run 都在 Flow 执行 页面独立记录，拥有各自的实时视图与历史。

同一 Agent 的会话与分支边界

同一 Run 实例 中，不同子任务若指派同一 Agent，会话进程及上下文共享、工作分支也共享，但任务会依次完成。既保证了工作记忆的延续性，又避免了并发冲突。
不同 Run 实例 中的同一 Agent，会话进程相互独立，工作分支绝对隔离。
不同 Flow 模板 中的同一 Agent，同样会话进程相互独立，工作分支绝对隔离。

Your first Flow in 5 minutes

There are two ways to create a Flow. Pick whichever fits how you think.

Option A — Describe it in natural language

On the Flow List page, use AI Decompose: type your goal in plain language and ClawsomeFlow drafts a Flow for you — tasks, dependencies and a leader summary task included. You then open it in the editor to fine-tune.

Option B — Build it by hand

On the Flow List page, click New Flow.
Give it a name and an overall goal (include what "done" looks like).
Pick a Leader and its agent source. The Leader will summarize the run.
Add tasks: for each, write what to do, choose an agent source, and set which tasks it depends on.
Save the Flow.
Back on the Flow List, click Run. Fill in any parameter fields, then start.
You're taken to the Run Details page — watch the agents work live.

✅

Not sure how to split the work? Start with AI Decompose, then tweak. You don't have to get the graph perfect — you can edit the Flow and run it again any time.

5 分钟创建你的第一个 Flow

创建 Flow 有两种方式，选你习惯的那种即可。

方式 A——用自然语言描述

在 Flow 列表 页面使用 AI 拆解：用自然语言输入你的目标， ClawsomeFlow 会为你起草一个 Flow——包含任务、依赖关系以及 Leader 的汇总任务。随后你可以打开编辑器进行微调。

方式 B——手动编排

在 Flow 列表 页面，点击 新建 Flow。
填写名称与 总体目标（写清楚「完成」的标准）。
选择一个 Leader 及其 Agent 来源。Leader 负责汇总整次运行。
添加任务：为每个任务写明要做什么、选择 Agent 来源，并设置它依赖哪些任务。
保存 Flow。
回到 Flow 列表，点击运行。填写参数字段后启动。
页面会跳转到 执行详情——实时观看 Agent 工作。

✅

不确定怎么拆分工作？先用 AI 拆解，再做调整。图不必一次到位——你随时可以编辑 Flow 并重新运行。

Building a Flow (the editor)

The Flow editor has two parts: the basics at the top, and the task graph below.

Flow basics

Flow name & Overall goal — describe the goal and your acceptance criteria. Agents read this.
Leader — pick the leader agent, its source, the workspace repo path, and the target branch its summary merges into.
Parameter fields (optional) — define inputs like "target project" so the same Flow can be reused with different values. You fill these in each time you run.

Task orchestration

For each task you set:

What to do — the instruction for that task.
Agent source — which CLI runs it (OpenClaw, Claude Code, Codex, …).
Dependencies — which tasks must finish first. Tasks with no unmet dependency run in parallel.

A task automatically receives the outputs of the tasks it directly depends on, so you can chain work without copy-pasting between agents.

⚠️

The Leader handles only the summary task. Don't try to assign ordinary worker tasks to the Leader — give those to other agents, and let the Leader gather everything at the end.

Reuse: merge an existing Flow

Merge existing Flow imports another Flow's worker tasks into this one (and de-duplicates parameter fields) — a quick way to combine building blocks you've already made.

编排一个 Flow（编辑器）

Flow 编辑器分为两部分：顶部的基础信息，以及下方的任务图。

Flow 基础信息

Flow 名称 与 总体目标——描述目标和验收标准，Agent 会读取这些内容。
Leader——选择 Leader Agent、其来源、工作区仓库路径，以及其汇总结果要合并到的目标分支。
参数字段（可选）——定义诸如「目标项目」之类的输入，让同一个 Flow 能用不同取值复用。每次运行时填写它们。

任务编排

每个任务需要设置：

要做什么——该任务的指令。
Agent 来源——由哪个 CLI 执行（OpenClaw、Claude Code、Codex……）。
依赖关系——必须先完成哪些任务。没有未满足依赖的任务会并行执行。

任务会自动收到它直接依赖的那些任务的产出，因此你无需在 Agent 之间手动复制粘贴即可串联工作。

⚠️

Leader 仅负责汇总任务。请不要把普通工作任务分配给 Leader—— 把这些任务交给其他 Agent，让 Leader 在最后汇总一切。

复用：合并已有 Flow

合并已有 Flow 会把另一个 Flow 的工作任务导入当前 Flow（并对参数字段去重）—— 是把你已经做好的「积木」快速组合起来的便捷方式。

Developer mode

Developer mode offers software-development collaboration projects a more flexible way to collaborate.

Upstream context for every subtask: for each direct dependency, a subtask is injected with the upstream agent id, worktree path, branch and base branch, so it can flexibly build on that work — inspect it, merge that branch, or raise a PR for it — driven entirely by your task description.
Cross-branch collaboration in plain language: in a downstream task, just write "merge upstream agent X's worktree branch into branch Y" or "open a PR for X".
Built-in lock = absolute parallel-merge reliability: many branches can develop and merge in parallel without ever racing or corrupting the repo. Whether the scheduler or an agent merges, every merge is serialized on the same lock — you can even direct cross-branch merges or PRs in plain language without risk.
Per-subtask auto-merge control: each subtask can independently toggle auto-merge into the baseline branch.
Unique worktree per agent: each agent creates its own worktree and independent branch from the baseline branch.
PR-friendly flow: for subtasks you want to land via PR or manual review, turn auto-merge OFF.

ℹ️

Within the same Run instance, if different subtasks are assigned to the same Agent, they share one session process and context, and one worktree branch, but tasks run one after another — preserving continuity of working memory while avoiding concurrent conflicts. Across different Runs, sessions and branches are fully isolated.

Flow Runtime Collaboration Architecture (English)

开发者模式

开发者模式为软件开发协作项目提供更灵活的协作方式。

每个子任务都拿到上游上下文：对每个直接依赖，子任务都会被注入上游的 Agent id、worktree 路径、分支与基线分支，从而可以灵活地在其成果之上继续——查看、合入该分支、或为其提 PR，完全由你的任务说明驱动。
自然语言直接指挥跨分支协作：在下游任务里只需写一句「把上游 Agent X 的 worktree 分支合入 Y 分支」或「为 X 提交 PR」。
内置锁 = 并行合入绝对可靠：多个分支可以并行开发与合入，永不竞争、永不损坏仓库。无论调度器还是 Agent，每次合入都在同一把锁上串行，你甚至可以用自然语言指挥跨分支合入/提 PR 而毫无风险。
逐子任务控制自动合入：每个子任务可独立设置是否自动合入到基线分支。
每个 Agent 拥有唯一 worktree：Agent 从基线分支创建自己的 worktree 与独立分支。
更适合 PR 协作：对希望走 PR 或手动审核合入的子任务，关闭其自动合入即可。

ℹ️

在同一 Run 实例中，不同子任务若指派同一 Agent，会话进程及上下文共享、工作分支也共享，但任务会依次完成。既保证了工作记忆的延续性，又避免了并发冲突。在不同 Run 之间，会话与分支严格隔离。

Running & monitoring a Run

When you run a Flow you land on Run Details. This is your live control room.

Task Execution Board — the graph of tasks, showing which are running, done, or waiting. Switch between a list view and a terminal view.
Terminal — peek into any agent's live terminal output as it works.
Live events — a running log of every dispatch, completion and failure. Each Run is fully traceable.
Stop flow execution — abort the Run if you need to. Changes are rolled back on termination.

You can run the same Flow several times at once — each Run gets its own isolated team and workspaces, so concurrent Runs never interfere with each other.

ℹ️

A Run finishes when the Leader's summary task is done — not when every single task on the board turns green. The Leader converging the work is the finish line.

运行与监控一次 Run

运行 Flow 后会进入 执行详情 页面。这是你的实时指挥室。

任务执行看板——任务图，显示哪些在运行、已完成或在等待。可在列表视图与终端视图间切换。
终端——实时查看任意 Agent 工作时的终端输出。
实时事件——记录每一次派发、完成与失败的运行日志。每次 Run 都完全可追溯。
停止流程执行——需要时可中止 Run。中止后改动会被回滚。

同一个 Flow 可以同时运行多次——每次 Run 拥有各自隔离的团队与工作区，因此并发的 Run 之间互不干扰。

ℹ️

当 Leader 的汇总任务完成时，整次 Run 即告结束——而不是等看板上每一个任务都变绿。 Leader 完成收敛就是终点线。

Reviewing & merging results

When the work is done, the Leader Work Report on the Run Details page is your single summary of what happened and what was delivered. Read it first.

Human checkpoints (review mid-run)

You don't have to wait until the very end to review. In the Flow editor, toggle Require post-task checkpoint (the ⛳ flag) on any task. When that task finishes, the whole Run pauses — its status becomes Awaiting your checkpoint decisions — and no task that depends on it starts until you act.

On the Run Details page, the checkpoint panel lets you:

Read the latest output of the checkpoint task.
Approve it — downstream tasks are then dispatched and the Run continues.
Rerun it with written feedback if it's not good enough — the same agent redoes the task. While a rerun is in progress, other checkpoints wait their turn.
Abort the flow from here if you want to stop entirely.

⛳

Use checkpoints to gate the risky or expensive steps — review an early task's output before the rest of the team builds on top of it, instead of finding a problem only at the end.

Approving merges

Because agents work on isolated branches, their results need to be merged into your target branch. How that happens depends on the agent source:

TUI agents (Claude Code, Codex, Gemini, …) default to manual merge. The Run pauses in Awaiting review and lists Pending merges. Read the Leader's merge advice, then click Merge into Target Branch — or Dismiss if you don't want it.
OpenClaw agents merge themselves as the last step of each task, so there's usually nothing for you to approve.

Run diff & reverting merges

Once a run finishes, the detail page shows a Run diff module (just below the Leader work report) listing every agent whose work was effectively merged into a baseline branch this run. Click an agent to view its full unified diff, syntax-highlighted.

Only agents with real merged changes appear — anything you dismissed, a merge that failed, or a merge with no net change is omitted; OpenClaw merges are not shown (they merge in-task).
Attribution is correct even when a baseline branch is shared by concurrent or scheduled runs: each run's own merge commits are isolated, so you only see this run's effective changes.
Revert a merge — any listed agent can be reverted with one click, at any time after the run. This runs a safe, non-destructive git revert (it adds inverse commits; it never rewrites history or edits files by any other means). If git can't do it cleanly (e.g. a conflict with later commits), nothing is changed and the reason is shown; reverted agents then drop out of the Run diff.

Easy mode

In the Flow editor basics, you can turn on Easy mode. Every agent then intelligently merges its changes into the target branch as each task finishes — including when multiple tasks run in parallel — so the Run never pauses in Awaiting review and you don't need to approve each item under Pending merges one by one.

When all work is done, a manual run still enters the complaint phase so you can give consolidated feedback. Human checkpoints in the Flow are still reviewed by you. A scheduled run instead finishes directly and skips the complaint phase.

Need per-subtask control over auto-merge instead? Use Developer mode (see Developer mode).

🛠️

If an automatic merge hits a git conflict, the UI shows the exact branches, repo path and a suggested command so you can finish it by hand. Your work is never lost — conflicting branches are preserved.

审阅与合并结果

工作完成后，执行详情页上的 Leader 工作报告 是对「发生了什么、交付了什么」的唯一汇总。请先阅读它。

人工检查点（运行中途审阅）

你不必等到最后才审阅。在 Flow 编辑器中，可为任意任务开启 启用任务后检查点 （⛳ 标记）。当该任务完成时，整次 Run 会暂停——状态变为 等待你的检查点决定——在你处理之前，依赖它的任务都不会开始。

在执行详情页的检查点面板中，你可以：

查看该检查点任务的最新产出。
批准——随后下游任务被派发，Run 继续运行。
若不够好，则附上文字反馈并重跑——由同一个 Agent 重做该任务。重跑进行期间，其他检查点会排队等待。
如需彻底停止，也可从这里中止流程。

⛳

用检查点为高风险或高成本的步骤把关——在团队其余成员基于某个早期任务的产出继续之前先行审阅它，而不是到最后才发现问题。

确认合并

由于 Agent 都在隔离分支上工作，它们的成果需要合并到你的目标分支。具体方式取决于 Agent 来源：

TUI 类 Agent（Claude Code、Codex、Gemini……）默认采用手动合并。此时 Run 会停在 等待审阅 状态，并列出 待合并 项。阅读 Leader 给出的合并建议后，点击 合并到目标分支——若不需要则点击忽略。
OpenClaw 类 Agent 会在每个任务的最后一步自行合并，因此通常无需你来确认。

Run diff 与撤销合入

运行结束后，执行详情页会显示 Run diff 模块（位于 Leader 工作报告下方），逐条列出本次 Run 中真正被合入某个基线分支的 Agent。点击任一 Agent 即可查看其完整、带高亮的 unified diff。

仅展示有效合入了改动的 Agent——被你忽略的、合并失败的、或没有净改动的都不显示； OpenClaw 的合入不展示（它们在任务内自行合并）。
即使基线分支被多个并发或定时 Run 共享，归属也准确：每个 Run 只隔离出自己的合入提交，你看到的始终是本次 Run 的有效改动。
撤销合入——运行结束后可随时对列表中任一 Agent 一键撤销。它执行的是安全、非破坏性的 git revert（新增反向提交来抵消，绝不改写历史、也不用其他手段强改文件）。若 git 无法干净完成（例如与后续提交冲突），则不做任何改动并告知原因；撤销后的 Agent 会从 Run diff 中移除。

省心模式

在 Flow 编辑器的基础信息中，你可以开启 省心模式。开启后，每个 Agent 会在任务完成时智能合入其修改到目标分支——即使多个任务并行执行也适用——Run 不会停在 等待审阅 状态，也无需你在执行详情页逐个确认 待合并 项。

全部任务完成后，手动触发的 Run 仍会进入投诉环节，便于你统一反馈；Flow 中的 人工检查点 依然由你来审阅。若是定时执行，则会在全部完成后直接结束，不进入投诉环节。

如需逐子任务控制是否自动合入，请使用 开发者模式（见开发者模式）。

🛠️

如果自动合并遇到 git 冲突，界面会显示确切的分支、仓库路径以及一条建议命令，便于你手动完成。你的工作绝不会丢失——存在冲突的分支会被保留下来。

The improvement loop (complaints)

After a Run completes, ClawsomeFlow gives you one more chance to push back before things are cleaned up. This is the complaint step.

Happy with the result? Confirm, and the Run wraps up.
Not happy? Submit a complaint describing what's wrong or what to improve.

On a complaint, the relevant agents reflect and write their improvements back into their workspaces, growing their experience on their own.

改进闭环（投诉）

一次 Run 完成后，在清理之前，ClawsomeFlow 还会给你一次「提要求」的机会。这就是投诉环节。

对结果满意？确认即可，本次 Run 收尾结束。
不满意？提交一条投诉，说明哪里不对、需要怎样改进。

收到投诉后，相关 Agent 会反思，并把改进写回各自的工作区，实现经验自增长。

Timed Flows

The Timed Flows page lets you schedule Flows to run automatically.

Set a run time, and choose one-time or recurring (with an interval in days).
Add one or more Flows to the schedule, and supply each Flow's input fields.
Choose how multiple Flows execute: parallel (all at once) or serial (one after another).
Review past runs under Execution Records.

定时 Flow

定时 Flow 页面让你安排 Flow 自动运行。

设置 运行时间，并选择 一次性 或 周期性（以天为间隔）。
向计划中添加一个或多个 Flow，并填写每个 Flow 的输入字段。
选择多个 Flow 的执行方式：并行（同时运行）或串行（依次运行）。
在 执行记录 中查看历史运行。

My Agent Team

The My Team section lets you chat directly with your agents — across every supported platform (OpenClaw, Hermes, Claude Code, Codex, and more) — in natural language. Use it to:

Run a single-agent task.
Ask an agent to take on expert skills or set up its own scheduled tasks.
Give feedback, share complaints, or suggest improvements — conversationally.
Get to know an agent before you put it to work inside a Flow.

Opening an agent's working area

An agent created for you works like a real human would: it has its own working area and materials, continuously organizing its work around its responsibilities and managing itself. From an agent's chat page you can open that area directly to browse everything it has produced and accumulated. The exact entry depends on the platform — an OpenClaw agent has a my-desktop/ folder (the my-desktop button), and Hermes exposes its my-profile root.

ℹ️

ClawsomeFlow doesn't affect how you use the underlying agent CLIs themselves at all — you can still define and use your team's agents directly in OpenClaw, Hermes, Claude Code, Codex, etc. the way you're used to.

我的Agent团队

我的团队 区域让你用自然语言直接与你的 Agent 对话——涵盖所有受支持的平台（OpenClaw、Hermes、Claude Code、Codex 等）。你可以用它来：

执行单 Agent 任务。
让 Agent 掌握专家技能，或为它设置自己的定时任务。
以对话方式给出反馈、提出投诉或改进建议。
在把某个 Agent 投入 Flow 之前，先熟悉它。

打开 Agent 的工作区

为你创建的 Agent 会像真实的人类一样工作：它拥有专属的工作区与资料，围绕自身职责持续整理与沉淀工作资料，实现自我管理。在 Agent 的对话页面上，你可以直接打开它的工作区，浏览其产出与沉淀的内容。具体入口因平台而异——OpenClaw Agent 有 my-desktop/ 文件夹（my-desktop 按钮）；Hermes 提供 my-profile 根目录。

ℹ️

ClawsomeFlow 完全不影响底层 Agent CLI 本身的使用，你仍可按照习惯，直接在 OpenClaw、Hermes、 Claude Code、Codex 等中定义和使用团队的 Agent。

External execution nodes

Humans, remote ClawsomeFlow instances, and any HTTP service can own a task in your DAG — same dependencies, hand off via completion summaries.

Flow editor → Owner source External execution → pick Human, Remote ClawsomeFlow, or Generic interface (webhook).

Remote ClawsomeFlow

Copy-paste wiring — no hand-typed CLI:

Peer: on the target Flow's editor click Copy remote call info and send the JSON to the origin.
Origin: pick Remote ClawsomeFlow, paste it into Remote Flow call info and save the subtask — registration is automatic. The secret is stored locally, never in the Flow.

No extra setup across machines — both ends are plain, symmetric ClawsomeFlow services. Remotes can reach only the credential-gated /api/external collaboration surface; the WebUI and every other API stay local-only (enforced by source IP; use an SSH tunnel for remote administration). If the remote Flow has param fields, upstream tasks are asked to report their values automatically.

Generic interface (webhook)

Set your endpoint URL on the node. When finished, your system POSTs:

POST {callbackUrl}
Authorization: Bearer {callbackToken}

{"status": "success", "summary": "what you delivered"}

外部执行节点

真人、远程 ClawsomeFlow、任意 HTTP 服务都可以成为 DAG 里的任务执行方—— 同样的依赖，用完成摘要交接。

Flow 编辑 → Owner 来源 外部执行 → 选人工、远程ClawsomeFlow 或 通用接口（webhook）。

远程ClawsomeFlow

复制粘贴接线，免手敲 CLI：

受理方：在目标 Flow 编辑页点复制远程调用信息，把得到的 JSON 发给发起方。
发起方：子任务选远程ClawsomeFlow，粘贴到远端 Flow调用信息后保存子任务即可自动注册。凭证只存本机，不写进 Flow。

跨机器无需额外配置——两端是完全对等的普通 ClawsomeFlow 服务。远程只能访问带凭证鉴权的 /api/external 协作面；WebUI 与其余 API 按来源 IP 只接受本机连接（远程管理走 SSH 隧道）。若远端 Flow 有参数字段，其上游任务会被自动要求回报这些字段的值。

通用接口（webhook）

在节点上填写你的端点 URL。完成后你的系统再 POST：

POST {callbackUrl}
Authorization: Bearer {callbackToken}

{"status": "success", "summary": "交付说明"}

MCP remote control

Run ClawsomeFlow as an MCP server. Point one of your agents at it and — through that agent's own channels (Feishu, Telegram, …) — you can, in plain language, ask which Flows exist, run one, and get the leader's final work report back. A typical loop: you send a file + a request over Telegram → the agent picks the right Flow and runs it → reads the leader report → replies over Telegram.

Talking to your agent

Once it's registered (below), just talk to the agent in your channel, in plain language — for example:

“What ClawsomeFlow flows can I run?”
“Run the XXXX task.”
“Show me the run result.”
“Cancel the XXX run.”

The agent organizes the inputs itself from your request, so you rarely name fields explicitly — describe the task and let it map your words onto the Flow's parameters.

Register it with your agent

csflow mcp install --platform hermes                # Hermes: default profile
csflow mcp install --platform hermes --agent <id>    # Hermes: a specific agent profile
csflow mcp install --platform codex                 # global platforms (claude / cursor / gemini / codex / opencode)
csflow mcp uninstall --platform codex               # remove it again

hermes — per-agent (--agent <id>; omit to target the default profile).
claude / cursor / gemini / codex / opencode — global config, written automatically.
openclaw / kimi / qwen / nanobot — not auto-configurable; use print-config and paste the snippet into the platform's own MCP config.

Writes are non-destructive and idempotent; install skips a platform whose CLI isn't on PATH unless you pass --force.

Manual configuration

Print a ready-to-paste snippet for any platform instead of writing files:

csflow mcp print-config --platform claude

The server entry is always the same command — register it manually if your platform isn't listed:

{
  "mcpServers": {
    "clawsomeflow": { "command": "csflow", "args": ["mcp", "serve"] }
  }
}

ℹ️

The ClawsomeFlow service must be running (csflow start) to use MCP.

MCP 远程控制

把 ClawsomeFlow 作为 MCP server 运行。把你的某个 Agent 接上它，就能通过该 Agent 自带的渠道（飞书、Telegram 等）用自然语言询问有哪些 Flow、执行某个 Flow，并拿回 leader 的最终工作汇报。典型闭环：你在 Telegram 发一个文件 + 一句需求 → Agent 选中合适的 Flow 并执行 → 读取 leader 汇报 → 通过 Telegram 回复你。

与 Agent 对话

注册完成后（见下），直接在渠道里用自然语言跟 Agent 说即可，例如：

“当前有哪些可用的 ClawsomeFlow 执行流？”
“执行 XXXX 任务。”
“给我看看运行结果。”
“停掉 XXX 任务。”

Agent 会从你的需求里自行组织参数，因此你很少需要显式点名字段——描述任务即可，它会把你的话映射到 Flow 的参数上。

把它注册到 Agent

csflow mcp install --platform hermes                # Hermes：默认 profile
csflow mcp install --platform hermes --agent <id>    # Hermes：指定某个 agent profile
csflow mcp install --platform codex                 # 全局平台（claude / cursor / gemini / codex / opencode）
csflow mcp uninstall --platform codex               # 移除

hermes——按 agent（--agent <id>；省略则写入默认 profile）。
claude / cursor / gemini / codex / opencode——全局配置，自动写入。
openclaw / kimi / qwen / nanobot——不支持自动配置；用 print-config 打印片段，粘贴到该平台自己的 MCP 配置里。

写入是非破坏式且幂等的；若某平台的 CLI 不在 PATH 中，install 会跳过，除非加 --force。

手动配置

也可以为任意平台打印可直接粘贴的配置片段，而不写文件：

csflow mcp print-config --platform claude

服务器条目始终是同一条命令——若你的平台不在上表中，手动注册它即可：

{
  "mcpServers": {
    "clawsomeflow": { "command": "csflow", "args": ["mcp", "serve"] }
  }
}

ℹ️

使用 MCP 前，ClawsomeFlow 服务必须处于运行状态（csflow start）。

Keeping ClawsomeFlow updated

When a new version is available, the console shows an upgrade badge in the sidebar — click it and follow the prompt to upgrade in place. Prefer the terminal? Run:

csflow upgrade

Your existing Flows, runs and settings are preserved across upgrades.

保持 ClawsomeFlow 更新

有新版本时，控制台侧边栏会出现 升级提示——点击它并按提示原地升级。更喜欢用终端？运行：

csflow upgrade

升级过程中，你已有的 Flow、运行记录和设置都会被保留。

Frequently asked questions

The points people most often misread — clearing these up saves a lot of confusion.

"Where are the execution results?"

TUI agents default to manual merge: the Run waits for you to approve the Pending merges on the Run Details page. OpenClaw agents merge themselves (unless the run is aborted). If you don't approve, the work stays on its branch, safe but not merged. If you want agents to auto-merge their changes, enable Easy mode.

"Can two agents step on each other?"

No. Each agent runs in its own isolated workspace and branch. Parallel work can't overwrite other parallel work; merging only happens deliberately, at the end or on your approval.

"Does one agent running several subtasks at once interfere with itself?"

No. Within the same Run instance, if different subtasks are assigned to the same Agent, they share one session process and context, and one working branch, but tasks run one after another — preserving continuity of working memory while avoiding concurrent conflicts. And across different Runs, the same agent's session and working directory are kept safely isolated, so concurrent Runs that share an agent never collide.

"Can I run the same Flow multiple times at once?"

Yes. Each Run is independent with its own team and workspaces, so concurrent Runs of the same Flow never interfere.

"Why do some agent platforms have an 'Agent management' page in My Team, and others don't?"

It reflects how each platform treats an agent. Platforms that offer Agent management let you shape a persistent team member — one with its own dedicated expertise, its own skills and tools, and a memory that keeps learning and accumulating across sessions. You create it once in My Team and reuse it run after run. Platforms that don't offer Agent management simply don't lean into that persistent-member model — but you can use them just as well: spin up a temporary agent right when you orchestrate a Flow (give it a working repo and a role) and it does the job for that run. And it goes both ways: even on the platforms that do support persistent members, you're free to create a temporary agent on the fly when you just need a one-off — you're never forced to register a persistent member first.

"Why can't I set a working directory for an OpenClaw agent?"

This comes from how the OpenClaw platform itself positions an agent: it isn't a tool you point at a folder — there is simply no "working directory" concept on that platform. An OpenClaw agent is a persistent digital member with its own desktop: a dedicated workspace it organizes and maintains by itself, where it keeps its notes, drafts and accumulated know-how across runs. ClawsomeFlow embraces that design instead of fighting it — you don't assign the agent a directory; the agent manages its own desk. What matters to you is the deliverables, and those are never locked inside that desktop: after each task the agent's key outputs are collected and presented in the leader's work report on the Run detail page, and code changes are self-merged into the baseline branch as part of the task itself.

"How do I bring my own agents in?"

ClawsomeFlow doesn't ship the agents themselves — it orchestrates the AI command-line tools you already have on your machine. So before an agent can run, make sure the tool it relies on (for example Hermes, OpenClaw, and the like) is installed locally and runnable from your terminal. ClawsomeFlow simply invokes that CLI inside the task's working repo; if the command isn't present on this machine, the task can't start. Install the tools you want to use first, then create agents that point at them.

"My agent stalls on a login screen / says 'not logged in' or returns auth errors."

Agents inherit the authentication of the CLI they run (model, provider, API key). So the first thing to check is your own CLI's model/provider config: open a terminal and confirm the tool works on its own — e.g. claude -p hi, a quick Hermes chat, or codex. If it isn't logged in or its provider/key is wrong, fix that first and the agent will work too. For Hermes you can also set the model, provider, base URL and API key per agent under Settings → Model (any OpenAI-compatible provider works).

"How do I use ClawsomeFlow on a headless server?"

Install and run ClawsomeFlow on the server as usual — a desktop on the server is not required. Then use SSH from your laptop to reach the Web console:

# On the server (Linux / macOS, no GUI needed)
curl -fsSL https://clawsomeflow.com/install.sh | bash
csflow start

# On your laptop — forward the console port (default 17017)
ssh -N -L 17017:127.0.0.1:17017 user@your-server

# Open in your local browser
http://localhost:17017

Flow orchestration, runs, chat, and file uploads all work over the tunnel. A few actions need a real local desktop on the same machine as the browser — the console detects remote access and disables them: native pick directory / open folder, dragging a folder into chat (paste server paths manually instead), and opening the Hermes dashboard or OpenClaw UI in a new tab. For repo paths, type the absolute path on the server (e.g. /home/you/project).

"How should I use Flow parameter fields?"

Flow parameter fields let one Flow serve many scenarios without duplicating the graph. In the Flow editor, add fields such as target project or release channel under Flow parameter fields (optional). Each time you run the Flow, you fill in the concrete values — and ClawsomeFlow injects them into every worker task's dispatch prompt under ## Runtime inputs (the leader summary task also receives the overall Flow goal). Task descriptions stay reusable; only the runtime values change.

Example: your marketing agent team delivers end-to-end campaigns. Instead of cloning a Flow per product, define one Flow with a parameter like target project. Run it once with Acme Widget and again with Beta App — same tasks, same agents, different repos, assets, and deliverables driven by the values you enter at run time. The task editor lists the fields you defined so you can reference them clearly in each sub-task description.

💬

Still stuck? Join the community from the homepage and ask — we're happy to help.

常见问题解答

大家最常误解的几个地方——把它们弄清楚能省去很多困惑。

「执行结果在哪？」

TUI 类 Agent 默认手动合并：Run 会等待你在执行详情页确认 待合并 项。 OpenClaw 类 Agent 会自行合并（除非执行流被中止）。如果你不确认，成果会留在它的分支上——安全，但尚未合并。如果你希望 Agent 自动合入它的修改，可以打开 省心模式。

「两个 Agent 会互相干扰吗？」

不会。每个 Agent 都在各自隔离的工作区与分支中运行。并行的工作不会覆盖彼此；合并只会在最后或经你确认后有意识地发生。

「同一 Agent 同时执行不同子任务会互相干扰吗？」

不会。同一 Run 实例 中，不同子任务若指派同一 Agent，会话进程及上下文共享、工作分支也共享，但任务会依次完成。既保证了工作记忆的延续性，又避免了并发冲突。此外，在不同的 Run 中，同一个 Agent 的会话与工作目录都是安全隔离的，因此共用同一 Agent 的并发 Run 之间也不会相互冲突。

「同一个 Flow 能同时运行多次吗？」

可以。每次 Run 相互独立，拥有各自的团队与工作区，因此同一 Flow 的并发 Run 互不干扰。

「为什么有的 Agent 平台在『我的团队』里有 Agent 管理，有的却没有？」

这取决于各平台如何看待一个 Agent。提供 Agent 管理的平台，让你能塑造一个持久的团队成员 ——它拥有独立的专长、专属的技能与工具，以及会随着一次次使用持续自学习、不断沉淀的记忆；你只需在 我的团队里创建一次，便可在之后的每次运行中复用。而未提供 Agent 管理的平台，平台本身并不强调这种「持久成员」的理念——但你照样能用好它：在编排任务流时临时创建一个 Agent （给它一个工作仓库与职责）即可，它会为这次运行完成工作。反过来也一样：即便在支持持久成员的平台上，当你只是需要一次性的执行者时，也可以随手创建一个临时 Agent，并不强制你必须先注册一个持久成员。

「为什么 OpenClaw Agent 不能指定工作目录？」

这首先取决于 OpenClaw 平台自身的定位：它的 Agent 不是一个「指向某个文件夹」的工具——平台本身就没有「工作目录」这一说法。OpenClaw Agent 是一位持久的数字成员，拥有属于自己的工作桌面：一个由它自己整理和维护的专属空间，笔记、草稿与经验沉淀都在这里跨任务积累。ClawsomeFlow 的设计顺应了这一理念——你不需要给它指派目录，Agent 自己打理自己的桌面。真正需要你关心的是交付物，而交付物不会被「锁」在桌面里：每次任务执行后，Agent 的关键输出会在执行详情页的 Leader 工作汇报 中呈现；代码类修改则由 Agent 在任务内自行合入基线分支。

「怎么把我自己的 Agent 带进来？」

ClawsomeFlow 本身不内置 Agent，它编排的是你本地已经装好的各类 AI 命令行工具。因此在 Agent 运行之前，请先确保它所依赖的工具（例如 Hermes、OpenClaw 等）已在本地安装，并且能在终端里正常调用。ClawsomeFlow 只是在任务的工作仓库中调用对应的 CLI；如果这台机器上没有这个命令，任务就无法启动。先把你想用的工具装好，再创建指向它们的 Agent 即可。

「我的 Agent 卡在登录界面／提示未登录／报认证错误。」

Agent 会继承它所运行 CLI 的认证（模型、提供商、API 密钥）。所以首先要排查的是你自己 CLI 的模型/提供商配置：打开终端，确认该工具能独立运行——例如 claude -p hi、快速用 Hermes 对话，或 codex。如果它没登录、或提供商/密钥配置有误，先修好它，Agent 也就能用了。对于 Hermes，你还可以在 设置 → 模型 中为每个 Agent 单独设置模型、提供商、Base URL 和 API 密钥（支持任何兼容 OpenAI 的提供商）。

「如何在无界面的服务器上使用 ClawsomeFlow？」

在服务器上照常安装并启动即可——不需要服务器有桌面环境。然后在你自己的电脑上通过 SSH 访问 Web 控制台：

# 在服务器上（Linux / macOS，无需 GUI）
curl -fsSL https://clawsomeflow.com/install.sh | bash
csflow start

# 在你自己的电脑上——转发控制台端口（默认 17017）
ssh -N -L 17017:127.0.0.1:17017 user@your-server

# 在本地浏览器打开
http://localhost:17017

Flow 编排、运行、聊天、上传附件等核心功能都可以通过隧道正常使用。以下几类操作在远程访问ClawsomeFlow控制台时需注意：选择目录 / 打开文件夹会被禁用（请改用手动粘贴远程服务器上的绝对路径替代），无法直接跳转服务器本地 Hermes Dashboard 或 OpenClaw UI。

「Flow 参数字段应该怎么用？」

Flow 参数字段的价值在于：一条 Flow 模板，多次复用。在 Flow 编辑器里的 Flow 参数字段（选填） 中定义如「目标项目」「发布渠道」等字段；每次运行前填写具体值， ClawsomeFlow 会把它们自动注入到每个 Worker 子任务 dispatch 提示词的 ## Runtime inputs 区块（Leader 汇总任务还会附带整体 Flow Goal）。任务说明本身可以写得更通用，真正随场景变化的是运行参数，而不是重复编排多条 Flow。

案例：你有一支 Agent 营销团队，需要为不同产品项目做端到端推广（调研、文案、落地页、数据复盘）。完全没必要为每个产品各建一条 Flow——只需编排一次，并设计「目标项目」等参数字段。第一次运行填写 Acme 小部件，第二次填写 Beta App：任务图与 Agent 分工不变，具体仓库、素材路径和交付口径由运行参数驱动。编辑子任务时，界面会列出你定义的字段名，方便在任务说明中引用。

💬

还有疑问？欢迎从主页加入社区提问——我们很乐意帮忙。

CLI commands

Everything in this guide can be done from the web console — the csflow CLI is here for automation and power users. Most people only ever need csflow start, csflow status and csflow upgrade. Every command also accepts --help for its full option list.

💬

Quoting text values: wrap any value that contains spaces or punctuation in quotes "…"; a single word (like an id) needs no quotes. For example --name "Backend Dev" needs quotes, while --id backend-dev does not. Each free-text command below shows a ready-to-copy example.

Lifecycle

csflow start [--port N] [--host ADDR] [--yes] [--skip-deps]

Check dependencies, apply any pending init/upgrade, (re)start the background service, and print the console URL. --port sets the HTTP port (default 17017); --host the bind address (default 127.0.0.1); --yes accepts all prompts with defaults; --skip-deps skips the dependency check.

csflow status

Show whether the service is running, plus an on-disk snapshot (version, mode, paths).

csflow stop [--grace SECONDS]

Stop the running service. --grace is how long to wait after a polite stop before forcing a kill (default 8s).

csflow upgrade

Upgrade to the latest stable release and reconcile your data. Your flows, runs and settings are preserved.

csflow doctor

Run a health check of dependencies, configuration, OpenClaw and the gateway.

csflow uninstall [--yes]

Stop the managed service, unregister from OpenClaw, and keep your local data at ~/.clawsomeflow/. --yes skips the confirmation prompt.

csflow uninstall --purge-data

Irreversible. Same teardown as uninstall, then delete the entire ~/.clawsomeflow/ directory. You must type the word PURGE to confirm (or pass --i-understand-this-deletes-everything for scripted runs). --yes does not skip this step.

csflow version

Print the installed version.

Flows

csflow flows list [--json]

List your flows. --json prints raw JSON instead of a table.

csflow flows show <flow_id> [--json]

Show one flow's full spec — its agents, tasks and dependencies. flow_id is the flow's id (see flows list).

Runs

csflow runs start <flow_id> [--input name=value ...] [--no-prompt]

Start a run of a flow. Supply the flow's parameter fields with a repeatable --input name=value; any field still missing is prompted for interactively. --no-prompt (or running without a terminal) turns a missing required field into an error instead of prompting.

# Quote the whole "name=value" when the value contains spaces:
csflow runs start customer-research \
  --input "target project=Acme CRM" --input locale=en

csflow runs list [--flow ID] [--status S] [--json]

List runs, optionally filtered by --flow (flow id) or --status (e.g. running, completed, failed).

csflow runs show <run_id> [--events N] [--json]

Show a run's status and pending merges. --events N also tails the N most-recent events.

csflow runs abort <run_id>

Stop an active run; in-flight changes are rolled back.

csflow runs merge <run_id> <agent_id>

Manually merge one agent's pending branch into the target branch (the CLI equivalent of approving a pending merge in the UI).

csflow runs dismiss-merge <run_id> <agent_id>

Drop a pending merge without merging — the agent's branch is preserved, nothing is landed.

csflow runs cleanup-history [--keep-days N] [--all] [--yes]

Delete old finished-run history to reclaim disk. --keep-days keeps the most recent N days (default 30); --all deletes everything; --yes skips the confirmation.

MCP (remote control)

csflow mcp install --platform P [--agent ID] [--name NAME] [--force]

Register the ClawsomeFlow MCP server with an agent platform. --platform is one of hermes / claude / cursor / gemini / codex / opencode (auto-written) or openclaw / kimi / qwen / nanobot (print-config only). For hermes, --agent ID targets one profile; omit it to use the default profile. --force writes even when the platform's CLI isn't on PATH.

csflow mcp uninstall --platform P [--agent ID] [--name NAME]

Remove the MCP server entry from a platform's config.

csflow mcp print-config --platform P [--name NAME]

Print a copy-pasteable MCP-server config snippet for a platform (no files written).

Diagnostics & maintenance

csflow logs tail [-n N] [-f] [--file PATH]

Tail the structured logs. -n sets how many lines (default 50); -f follows live; --file overrides the log file.

csflow logs export <target> [--overwrite]

Bundle logs into a .zip at target for sharing or diagnosis.

csflow api-token [--rotate]

Show the bearer token guarding the local API (for external callers on this machine). --rotate issues a new one.

csflow init (alias csflow install) [--port N] [--force] [--yes]

First-time install / re-initialize on this machine. --force overwrites an existing config. Normally you just run csflow start.

⚠️

agents remove-hard and uninstall --purge-data permanently delete data. Double-check the id and back up anything you care about first.

CLI 命令

本指南中的一切都可以在 Web 控制台完成——csflow 命令行主要面向自动化与进阶用户。大多数人只会用到 csflow start、csflow status 和 csflow upgrade。每条命令都可加 --help 查看完整选项。

💬

文本值的引号：凡是包含空格或标点的值，都要用引号 "…" 包起来；单个词（如 id）则无需引号。例如 --name "Backend Dev" 需要引号，而 --id backend-dev 不需要。下面每条需要输入文本的命令都附了可直接复制的示例。

生命周期

csflow start [--port N] [--host ADDR] [--yes] [--skip-deps]

检查依赖、执行待处理的初始化/升级、（重新）启动后台服务，并打印控制台地址。 --port 设置 HTTP 端口（默认 17017）；--host 设置绑定地址（默认 127.0.0.1）；--yes 以默认值接受所有确认；--skip-deps 跳过依赖检查。

csflow status

显示服务是否在运行，以及本地快照（版本、模式、路径）。

csflow stop [--grace SECONDS]

停止正在运行的服务。--grace 为温和停止后强制结束前的等待秒数（默认 8 秒）。

csflow upgrade

升级到最新稳定版并对账数据。你的 Flow、运行记录与设置都会被保留。

csflow doctor

对依赖、配置、OpenClaw 与网关做一次健康检查。

csflow uninstall [--yes]

停止托管服务、从 OpenClaw 注销，并保留 ~/.clawsomeflow/ 本地数据。 --yes 跳过确认提示。

csflow uninstall --purge-data

不可恢复。执行与默认 uninstall 相同的服务停止与 OpenClaw 反注册后，删除整个 ~/.clawsomeflow/ 目录。须输入 PURGE 确认（脚本化可加 --i-understand-this-deletes-everything）。 --yes 不能跳过此确认。

csflow version

打印已安装的版本号。

Flow

csflow flows list [--json]

列出你的 Flow。--json 输出原始 JSON 而非表格。

csflow flows show <flow_id> [--json]

显示某个 Flow 的完整配置——Agent、任务与依赖。flow_id 为 Flow 的 id（见 flows list）。

运行（Run）

csflow runs start <flow_id> [--input name=value ...] [--no-prompt]

启动一次 Flow 运行。用可重复的 --input name=value 提供该 Flow 的参数字段；仍缺失的字段会进入交互式询问。--no-prompt（或在无终端环境下运行）会把缺失的必填字段直接报错，而不再询问。

# 当值含空格时，把整个 "name=value" 用引号包起来：
csflow runs start customer-research \
  --input "target project=Acme CRM" --input locale=en

csflow runs list [--flow ID] [--status S] [--json]

列出运行记录，可用 --flow（Flow id）或 --status（如 running、completed、failed）过滤。

csflow runs show <run_id> [--events N] [--json]

显示某次运行的状态与待合并项。--events N 额外展示最近 N 条事件。

csflow runs abort <run_id>

中止一次进行中的运行；进行中的改动会被回滚。

csflow runs merge <run_id> <agent_id>

手动把某个 Agent 的待合并分支合并到目标分支（相当于在界面里确认一次待合并）。

csflow runs dismiss-merge <run_id> <agent_id>

放弃一项待合并而不执行合并——该 Agent 的分支被保留，不落地任何改动。

csflow runs cleanup-history [--keep-days N] [--all] [--yes]

删除旧的已结束运行历史以回收磁盘。--keep-days 保留最近 N 天（默认 30）；--all 全部删除；--yes 跳过确认。

MCP（远程控制）

csflow mcp install --platform P [--agent ID] [--name NAME] [--force]

把 ClawsomeFlow MCP server 注册到某个 Agent 平台。--platform 取 hermes / claude / cursor / gemini / codex / opencode（自动写入）或 openclaw / kimi / qwen / nanobot（仅 print-config）。对 hermes， --agent ID 指定单个 profile；省略则写默认 profile。--force 在平台 CLI 不在 PATH 时也强制写入。

csflow mcp uninstall --platform P [--agent ID] [--name NAME]

从某个平台的配置中移除该 MCP server 条目。

csflow mcp print-config --platform P [--name NAME]

打印某平台可直接粘贴的 MCP server 配置片段（不写文件）。

诊断与维护

csflow logs tail [-n N] [-f] [--file PATH]

查看结构化日志。-n 指定行数（默认 50）；-f 实时跟随；--file 覆盖日志文件路径。

csflow logs export <target> [--overwrite]

把日志打包成 .zip（位于 target），便于分享或排查。

csflow api-token [--rotate]

显示用于保护本机 API 的 Bearer 令牌（供本机上的外部调用者使用）。--rotate 生成新令牌。

csflow init（别名 csflow install）[--port N] [--force] [--yes]

在本机首次安装／重新初始化。--force 覆盖已有配置。通常你只需运行 csflow start。

⚠️

agents remove-hard 与 uninstall --purge-data 会永久删除数据。请先核对 id 并备份重要内容。