Skip to content
Back to search

retinue

Self-hosted coordination for AI workers: per-task graphs, device/model timelines, progress receipts, and source-aware usage. MIT.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/jklthinking--retinue/badge.svg)](/listings/jklthinking--retinue)

HTML

<a href="/listings/jklthinking--retinue"><img src="/api/listings/jklthinking--retinue/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 526 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # Retinue (众卿) — self-hosted task board for humans and AI agents
  2. [![License: AGPL-3.0-only](https://img.shields.io/badge/license-AGPL--3.0--only-blue.svg)](LICENSE)
  3. [![Python 3.11+](https://img.shields.io/badge/python-3.11%2B-3776ab.svg)](pyproject.toml)
  4. [![MCP](https://img.shields.io/badge/MCP-server-6f42c1.svg)](docs/agent-onboarding.md)
  5. [![Self-hosted](https://img.shields.io/badge/self--hosted-no%20telemetry-2ea44f.svg)](SELF_HOSTING.md)
  6. **English** · [简体中文](#众卿-retinue简体中文) · [English demo](https://jklthinking.github.io/retinue/demo-en/?lang=en) · [中文演示](https://jklthinking.github.io/retinue/demo/?lang=zh-CN)
  7. The dashboard now switches between English and 简体中文. The language preference
  8. is saved locally and preserves the selected task/page. User-authored task content
  9. is retained. See the [English PRD](docs/PRD.en.md), [English screenshots and release
  10. notes](docs/releases/2026-10-03-english-edition.md), and [English sharing draft](docs/sharing/english.md).
  11. **Retinue** (Chinese name **众卿**, "the assembled ministers") is a
  12. self-hosted task board and orchestration hub where a mixed team of people and
  13. AI agents work the same cards. Every piece of work is one durable baton: a
  14. task card with a single holder, an acceptance check, and an append-only
  15. receipt chain. You run the board, agents claim work over MCP or HTTP, they
  16. write back, and you accept the card or send it back. There is no hosted
  17. control plane, no vendor account requirement, and no telemetry. The server-backed
  18. hub uses operator-managed local accounts and scoped credentials.
  19. ## 2026-10-07: model quota on Home
  20. Version `0.3.0a5` is the first AGPL-3.0-only release. Task conversation histories remain behind an opt-in flag. [Release notes](docs/releases/2026-10-08-task-conversations.md). Manual quota refresh remains available.
  21. Opt-in node quota collection and bilingual Home cards for
  22. Claude, Codex, Grok, Cursor and Kimi subscriptions, plus Moonshot API balance.
  23. See used percentages, reset time, report age and labelled last-successful data.
  24. [Setup and API semantics](docs/node-quota.en.md) ·
  25. [Update notes](docs/releases/2026-10-07-model-quota.md) ·
  26. [Conversation timeline design](docs/design/collaboration-conversations.md).
  27. Existing servers require the explicit schema-26 migration; collectors stay off
  28. until enabled locally. The online demos show synthetic data only.
  29. ## 2026-10-03 English edition: visible collaboration
  30. Version `0.3.0a1` brings the collaboration process into each task. See who
  31. delegated to whom, what each device/model worker reported, what it is waiting
  32. for, and which artifact supports the next handoff.
  33. | View | What it explains |
  34. |---|---|
  35. | Home | The original task flow, dispatch coordination, and session flow views |
  36. | Per-task graph | Explicit delegation, dependencies, baton movements, and review returns |
  37. | Device/model timeline | Recorded runs with identity snapshots and source labels |
  38. | Module contributions | Explicit functional assignments, reported work, remaining items, and artifact references |
  39. | Node details and context | Instructions, acceptance criteria, waiting owners, progress, evidence versions, and next-step intent |
  40. | Operations and data quality | Separate sources, reported usage coverage, receipt freshness, and retained history |
  41. Read-only cc-connect observers match native sessions to Claude records and
  42. deduplicate usage by stable deliveries. A worker is an execution identity;
  43. session transports and observers are listed separately. The operations view
  44. has one primary implementation, while the existing task and session modes
  45. remain available.
  46. **Boundaries:** delegation does not launch a model, observation does not invent
  47. task progress, an executor's claim is not independent acceptance, and reported
  48. usage is not a complete provider bill. Explicit task bindings and structured
  49. receipts are needed to follow real work. GitHub retains code/PR/CI evidence;
  50. Retinue retains holder, lease, task state, and collaboration events.
  51. All screenshots below use the deterministic, read-only **synthetic demo**
  52. (`seed=42`).
  53. Its product-launch example illustrates the UI and protocol, not real model
  54. execution or an end-to-end production acceptance result. Collaboration images
  55. show one fixed task; timestamps come from staged synthetic demo time, not
  56. production activity.
  57. ![Synthetic Retinue home: task flow, dispatch coordination, and session flow](docs/images/2026-10-03-en/01-home.jpg)
  58. ![Synthetic per-task collaboration: relationships, device/model lanes, and module contributions](docs/images/2026-10-03-en/02-task-collaboration.jpg)
  59. [Operations screenshot](docs/images/2026-10-03-en/03-operations.jpg) ·
  60. [Data-quality screenshot](docs/images/2026-10-03-en/04-data-quality.jpg) ·
  61. [Device/model lanes](docs/images/2026-10-03-en/05-worker-lanes.jpg) ·
  62. [Module contributions](docs/images/2026-10-03-en/06-module-contributions.jpg) ·
  63. [Branch details](docs/images/2026-10-03-en/07-branch-detail.jpg) ·
  64. [Home dispatch and session flow](docs/images/2026-10-03-en/08-home-dispatch.jpg) ·
  65. [Full update notes](docs/releases/2026-10-03-english-edition.md) ·
  66. [English PRD](docs/PRD.en.md) · [Sharing draft](docs/sharing/english.md)
  67. ## What is Retinue?
  68. Retinue is a **self-hosted, local-first task board for AI agents and the
  69. people who supervise them**. It is not a chat wrapper and not an agent
  70. framework — it is the shared board and audit layer that sits underneath
  71. whatever agents you already run (Claude Code, OpenAI Codex, any MCP client,
  72. or a human with a browser).
  73. - **One holder per card.** Work is never ambiguous: exactly one actor holds
  74. the baton, and only the holder can write. Another agent's token gets
  75. `403 holder-only-writes`.
  76. - **Append-only receipt chain.** Claim, progress, hand-off, block, and
  77. acceptance are all recorded and cannot be rewritten after the fact.
  78. - **Acceptance checks on the card.** A card says what "done" means before an
  79. agent starts. Recorded completion and independent quality verification
  80. remain separate observations.
  81. - **MCP-native coordination.** `retinue-server mcp` exposes the board to any
  82. MCP-capable agent; there is also a plain HTTP + bearer-token API.
  83. - **Runtime exporters.** Read-only importers for Claude Code and Codex
  84. session data give you token activity per agent without touching sources.
  85. - **Optional IM adapters.** Lark/Feishu and Telegram bridges turn a chat
  86. message into an intent — never directly into a command.
  87. - **Data sovereignty.** File mode keeps canonical state in one data directory
  88. (`org.yaml`, `tasks/`, `metrics/`, `nodes/`); stop writers before copying it.
  89. The server stores canonical state in `retinue.db`; use a consistent SQLite
  90. snapshot for its backup. Runtime source records, external artifacts,
  91. credentials and deployment configuration have separate recovery paths.
  92. See the [backup guide](SELF_HOSTING.md#backup).
  93. ## Who it is for
  94. Individuals and small teams running a **fleet of AI coding agents** who want
  95. one durable board, observable receipts, and data they can take away — without
  96. adopting a hosted agent platform. It runs on one machine, a homelab box, or a
  97. NAS.
  98. ## How Retinue differs
  99. | | Retinue | Trello / Jira / Linear | Agent frameworks (LangGraph, CrewAI, AutoGen) |
  100. |---|---|---|---|
  101. | Primary users | People **and** AI agents on the same cards | People | Agents, in code |
  102. | Where it runs | Your machine, self-hosted | Vendor SaaS | Inside your app process |
  103. | Audit | Append-only receipt chain per card | Activity log, editable | Traces, usually ephemeral |
  104. | Agent access | MCP server + token-scoped HTTP API | Bots and webhooks bolted on | N/A — it *is* the agent |
  105. | Write safety | Holder-only writes, hooks only from `org.yaml` | Anyone with access | Whatever you code |
  106. | Telemetry | None | Vendor-side | Varies |
  107. Retinue does not replace your agent runtime. It replaces the spreadsheet,
  108. the chat thread, and the "which agent is doing what right now?" question.
  109. ## Ten-minute corridor
  110. The path below stays on loopback. Credentials stay in the environment, never
  111. in a card.
  112. ### 1. Start the hub with Compose
  113. Host port 9219 must be free (`docker compose` fails with "address already
  114. in use" otherwise). The admin password must be at least eight characters.
  115. ```bash
  116. read -rsp 'Choose an admin password (at least 8 characters): ' RETINUE_ADMIN_PASSWORD
  117. printf '\n'
  118. export RETINUE_ADMIN_PASSWORD
  119. docker compose up --build
  120. ```
  121. Wait until the logs show the hub listening, then:
  122. ```bash
  123. curl -fsS http://127.0.0.1:9219/api/health
  124. ```
  125. That returns JSON like `{"status":"ok","version":"0.3.0a5"}` with no
  126. authentication. `version` is the PEP 440 string from `pyproject.toml` (the
  127. same spelling as the wheel name and the next git tag, `v0.3.0a5`). Open
  128. <http://127.0.0.1:9219/> and sign in as `operator` with that password. The
  129. image is the authenticated v0.2 hub, not the old read-only panel.
  130. ### 2. Open a card
  131. Onboard the agent first: sidebar **Administration** → prepare an executor with actor
  132. id `worker-1`, save the one-time token outside the data volume. Then open
  133. **Task workspace** → **Task board** → **New task** and publish:
  134. - Title: `Write hello.txt with: hello from retinue`
  135. - Holder: `worker-1` (the agent that will claim it; do not leave this as
  136. yourself if you will use the agent token in the next step)
  137. - Priority: `high`
  138. - Acceptance: `hello.txt contains exactly: hello from retinue`
  139. Copy the generated task id (`task-YYYYMMDD-NNN`).
  140. The same card can be published over HTTP after you sign in (session cookie)
  141. or with an admin bearer. The holder must be `worker-1`.
  142. ### 3. Agent claim
  143. Use the one-time token from step 2:
  144. ```bash
  145. export RETINUE_AGENT_TOKEN='<one-time-agent-token>'
  146. export RETINUE_TASK_ID='<task-id-from-the-board>'
  147. curl --fail --request POST \
  148. --header "Authorization: Bearer $RETINUE_AGENT_TOKEN" \
  149. --header 'Content-Type: application/json' \
  150. --data '{"status":"doing","note":"claimed through the agent API"}' \
  151. "http://127.0.0.1:9219/api/tasks/$RETINUE_TASK_ID/update"
  152. ```
  153. MCP-capable agents can use `retinue-server mcp` after
  154. `pip install 'retinue[mcp]'` instead of learning curl. See
  155. [`docs/agent-onboarding.md`](docs/agent-onboarding.md).
  156. ### 4. Write back
  157. ```bash
  158. curl --fail --request POST \
  159. --header "Authorization: Bearer $RETINUE_AGENT_TOKEN" \
  160. --header 'Content-Type: application/json' \
  161. --data '{"progress":80,"refs":["artifact:hello.txt"],"note":"recorded the result reference"}' \
  162. "http://127.0.0.1:9219/api/tasks/$RETINUE_TASK_ID/update"
  163. ```
  164. ### 5. Acceptance
  165. When the acceptance line is actually true:
  166. ```bash
  167. curl --fail --request POST \
  168. --header "Authorization: Bearer $RETINUE_AGENT_TOKEN" \
  169. --header 'Content-Type: application/json' \
  170. --data '{"status":"done","note":"acceptance checked; hello.txt matches"}' \
  171. "http://127.0.0.1:9219/api/tasks/$RETINUE_TASK_ID/update"
  172. ```
  173. Refresh the board. The card is in `done` and the chain shows claim, write-back,
  174. and completion. A token issued for a different agent receives
  175. `403 holder-only-writes`.
  176. A file-mode corridor (no Docker) is in
  177. [`docs/closed-loop-walkthrough.md`](docs/closed-loop-walkthrough.md).
  178. Installation, backup, and exposure warnings are in
  179. [`SELF_HOSTING.md`](SELF_HOSTING.md).
  180. ## Architecture (one page)
  181. ```text
  182. operator agents
  183. | |
  184. | org.yaml (hooks only) | MCP or HTTP + actor token
  185. v v
  186. +------------------------------------------------------+
  187. | RETINUE hub |
  188. | task cards -- holder, acceptance, append-only chain |
  189. | claim / update / receipt / handoff / block |
  190. | optional IM adapter (intent in, never a command) |
  191. +------------------------+-----------------------------+
  192. |
  193. +---------------+----------------+
  194. | |
  195. read-only board node reports
  196. 127.0.0.1 panel heartbeat + CLI inventory
  197. GET only node token, no card writes
  198. ```
  199. File mode keeps canonical state in the selected data directory; stop writers
  200. before copying it. Server mode uses `retinue.db` and needs a consistent SQLite
  201. snapshot. Runtime source records, external artifacts, credentials and deployment
  202. configuration are recovered separately; see [Backup](SELF_HOSTING.md#backup).
  203. Agents never choose `on_claim` hooks; file-mode hooks come only from `org.yaml`.
  204. ## FAQ
  205. **What is Retinue used for?**
  206. Assigning work to a mix of humans and AI agents on one self-hosted board, and
  207. keeping a verifiable record of who held each card, what they claimed, and
  208. whether the acceptance check actually passed.
  209. **Does Retinue work with Claude Code, Codex, or other MCP clients?**
  210. Yes. MCP-capable agents connect through `retinue-server mcp`. Agents without
  211. MCP use the HTTP API with a scoped actor token. Claude Code and Codex also
  212. have read-only session exporters for token activity.
  213. **Is Retinue open source?**
  214. Retinue is open source under AGPL-3.0-only, with optional commercial licensing.
  215. Personal and commercial use are free when you comply with AGPL.
  216. See [LICENSE](LICENSE) and [COMMERCIAL.md](COMMERCIAL.md).
  217. **Does Retinue send my data anywhere?**
  218. No. There is no telemetry, no hosted control plane, no remote account, and no
  219. mandatory outbound request. The core, panel, daemon, demo, and exporters all
  220. work offline. Only IM adapters you explicitly configure contact anything.
  221. **Can I self-host Retinue on a homelab or NAS?**
  222. Yes. `docker compose up --build` brings up the hub on one host port; the
  223. loopback corridor below is the ten-minute path. See
  224. [`SELF_HOSTING.md`](SELF_HOSTING.md) for exposure warnings and backup.
  225. **How is Retinue different from an AI kanban board like Vibe Kanban?**
  226. Retinue is board *plus* audit boundary. Agents are treated as untrusted
  227. executors: they can never choose the hook that runs, only the operator's
  228. `org.yaml` can; writes are holder-only; and the receipt chain is append-only.
  229. The board is the governance surface, not just a task queue.
  230. **Does Retinue require Docker?**
  231. No. There is a file-mode corridor with no Docker in
  232. [`docs/closed-loop-walkthrough.md`](docs/closed-loop-walkthrough.md).
  233. ## License
  234. Copyright (c) 2026 JKL Thinking. The current source tree uses
  235. **AGPL-3.0-only**, with a separate commercial licensing option.
  236. - Personal use and internal company use are free, including commercial use.
  237. - If you modify Retinue and provide it to outside users over a network, you
  238. must offer those users the modified version's Corresponding Source under AGPL.
  239. - If you do not want to meet those requirements, you can buy a commercial license.
  240. Contact: [jklthinking@foxmail.com](mailto:jklthinking@foxmail.com).
  241. - **Versions 0.3.0a4 and earlier released under MIT remain MIT forever.**
  242. Distribution and other uses must also meet the applicable AGPL requirements.
  243. This applies to the development tree after that cutoff; old releases and tags
  244. are unchanged. See [LICENSE](LICENSE), [NOTICE](NOTICE),
  245. [commercial terms](COMMERCIAL.md), [contributor agreement](CLA.md) and
  246. [trademarks](TRADEMARKS.md). Third-party dependencies retain their own terms;
  247. see [THIRD_PARTY_NOTICES](docs/THIRD_PARTY_NOTICES.md).
  248. ---
  249. ## Community
  250. RETINUE is announced and discussed on the [LINUX DO](https://linux.do) community.
  251. Issues and pull requests are welcome on GitHub.
  252. # 众卿 RETINUE(简体中文)
  253. **众卿 Retinue** 是一套可自托管的 **AI 智能体任务看板与多智能体编排中枢**:
  254. 人和 AI agent 共用同一批任务卡。每一件工作对应一张任务卡——有唯一持有人、
  255. 有可观测的验收条件、有只可追加的回执链。你来跑看板,agent 通过 MCP 或 HTTP
  256. 认领,回写结果,你验收或退回。没有托管控制面或第三方账号要求,也没有遥测;
  257. 服务端中枢使用部署方管理的本地账号与限定范围的凭据。
  258. ## 2026-10-02 社区更新:看清每项任务的协作
  259. 版本 `0.3.0a1` 补齐每任务的关系图、设备/模型时间泳道和功能模块贡献。
  260. 点击节点可以查看委派指令、进展、等待对象、成果引用和下一步;新会话通过只读
  261. 任务上下文了解验收条件、已有状态记录和尚未核验的工作声明。
  262. 首页的任务流转、派单协调和会话流转台继续保留。运营效率入口统一,任务看板、
  263. 列表、协作空间、历史会话和实时会话仍各有自己的用途。执行 Worker 标清设备、
  264. runtime 与模型;同步与观察服务单列,不算作执行者。
  265. cc-connect 原生会话观察以只读方式接入,用量按实际消息模型分层、稳定 delivery
  266. 标识去重。运营看板把任务事件、runtime 日报和会话累计来源分开解释,未上报
  267. 显示未知,采集回执与模型最后活动分别说明。
  268. 委派排队不代表模型已启动,原生会话采集不自动生成任务进度,任务 done 记录也
  269. 不代表独立验收。真实任务仍需显式绑定与结构化回执。GitHub 保存代码、PR 和 CI
  270. 证据;Retinue 保存 holder、租约、任务状态与协作事件。
  271. 上方配图均为固定种子的**合成演示**;协作图、泳道、模块和分支详情展示同一固定
  272. 任务,时间来自分阶段演示时钟。图片不包含真实业务记录,不声称真实模型闭环
  273. 已全部通过验收。当前自有代码采用 AGPL-3.0-only,第三方声明保留,历史标签许可不改写。
  274. 查看 [完整版本说明](docs/releases/2026-10-02-collaboration-observability.md)、
  275. [PRD](docs/PRD.md)、[小红书草稿](docs/sharing/xiaohongshu.md);
  276. 也可打开 [只读演示](docs/demo/index.html)。
  277. ## 众卿 Retinue 是什么
  278. 它是**本地优先、可自托管的 AI agent 任务板与审计层**,不是聊天壳,也不是
  279. agent 框架。它垫在你已经在用的 agent(Claude Code、OpenAI Codex、任意 MCP
  280. 客户端,或者一个开着浏览器的人)下面。
  281. - **一卡一持有人**:同一时刻只有一个执行者握棒,只有持有人能写。别的 agent
  282. 的令牌会收到 `403 holder-only-writes`。
  283. - **只可追加的回执链**:认领、进度、交接、阻塞、验收全部留痕,事后改不掉。
  284. - **验收条件写在卡上**:开工前写清「怎样算完成」,任务完成记录与独立质量
  285. 核验分别解释。
  286. - **原生 MCP 协作**:`retinue-server mcp` 把看板暴露给任意 MCP agent;也提供
  287. 纯 HTTP + bearer token 接口。
  288. - **运行时 exporter**:只读导入 Claude Code / Codex 会话数据,按 agent 看
  289. token 消耗,不改动来源。
  290. - **可选 IM 适配器**:飞书 / Lark 与 Telegram 桥接把聊天消息变成「意图」,
  291. 绝不直接变成命令。
  292. - **数据主权**:文件模式的事实源是一个数据目录(`org.yaml`、`tasks/`、
  293. `metrics/`、`nodes/`),停掉写入者后复制;服务端事实源是 `retinue.db`,
  294. 使用一致性 SQLite 快照备份。运行时源记录、外部成果、凭据与部署配置
  295. 分别恢复,详见[备份说明](SELF_HOSTING.md#backup)。
  296. ## 适合谁
  297. 手上跑着**一队 AI 编程 agent** 的个人和小团队:想要一块持久的看板、可观测的
  298. 回执、随时能带走的数据,又不想被托管平台绑住。单机、homelab 主机、NAS 都能跑。
  299. ## 十分钟走廊
  300. 以下步骤只走本机回环。凭据放在环境变量里,不写进任务卡。
  301. ### 1. 用 Compose 起完整中枢
  302. 本机 9219 端口必须空闲(否则 compose 会报 address already in use)。
  303. 管理员密码至少八位。
  304. ```bash
  305. read -rsp 'Choose an admin password (at least 8 characters): ' RETINUE_ADMIN_PASSWORD
  306. printf '\n'
  307. export RETINUE_ADMIN_PASSWORD
  308. docker compose up --build
  309. ```
  310. 等日志里出现监听后再探活:
  311. ```bash
  312. curl -fsS http://127.0.0.1:9219/api/health
  313. ```
  314. 应返回类似 `{"status":"ok","version":"0.3.0a5"}`,无需登录。`version`
  315. 与 `pyproject.toml`、wheel 文件名、下次 git tag(`v0.3.0a5`)是同一串。
  316. 打开 <http://127.0.0.1:9219/>,用 `operator` 和上面的密码登录。默认镜像
  317. 是带登录的 v0.2 中枢,不再是旧只读面板。
  318. ### 2. 开一张卡
  319. 先在侧栏 **管理** 入职执行者 `worker-1`,把一次性令牌存到数据卷以外。
  320. 再到 **任务看板** → **新建任务**:
  321. - 标题、持有人填 `worker-1`(下一步要用该 agent 的令牌认领,不要填成
  322. 你自己)
  323. - 优先级 `high`,写上可观测的验收条件
  324. 记下任务 id(`task-YYYYMMDD-NNN`)。
  325. ### 3. Agent 认领
  326. 用第 2 步的一次性令牌:
  327. ```bash
  328. export RETINUE_AGENT_TOKEN='<one-time-agent-token>'
  329. export RETINUE_TASK_ID='<task-id-from-the-board>'
  330. curl --fail --request POST \
  331. --header "Authorization: Bearer $RETINUE_AGENT_TOKEN" \
  332. --header 'Content-Type: application/json' \
  333. --data '{"status":"doing","note":"claimed through the agent API"}' \
  334. "http://127.0.0.1:9219/api/tasks/$RETINUE_TASK_ID/update"
  335. ```
  336. ### 4. 回写
  337. ```bash
  338. curl --fail --request POST \
  339. --header "Authorization: Bearer $RETINUE_AGENT_TOKEN" \
  340. --header 'Content-Type: application/json' \
  341. --data '{"progress":80,"refs":["artifact:hello.txt"],"note":"recorded the result reference"}' \
  342. "http://127.0.0.1:9219/api/tasks/$RETINUE_TASK_ID/update"
  343. ```
  344. ### 5. 验收
  345. 验收条件真正成立后再把卡标为 `done`:
  346. ```bash
  347. curl --fail --request POST \
  348. --header "Authorization: Bearer $RETINUE_AGENT_TOKEN" \
  349. --header 'Content-Type: application/json' \
  350. --data '{"status":"done","note":"acceptance checked; hello.txt matches"}' \
  351. "http://127.0.0.1:9219/api/tasks/$RETINUE_TASK_ID/update"
  352. ```
  353. 刷新看板。卡在 `done`,事件链上能看到认领、回写和完成。另一名
  354. agent 的令牌会得到 `403 holder-only-writes`。
  355. 文件总线走廊见
  356. [`docs/closed-loop-walkthrough.md`](docs/closed-loop-walkthrough.md)。安装、
  357. 备份和暴露警告见 [`SELF_HOSTING.md`](SELF_HOSTING.md)。
  358. ## 架构一页图
  359. 见上方英文节的文字架构图。文件模式的事实源是运营者选定的数据目录,停掉
  360. 写入者后复制;服务端使用 `retinue.db`,需要一致性 SQLite 快照。运行时源记录、
  361. 外部成果、凭据与部署配置分别恢复,详见[备份说明](SELF_HOSTING.md#backup)。
  362. 文件模式的 `on_claim` 钩子只来自 `org.yaml`,任务卡不能指定要执行的命令。
  363. ## 常见问题
  364. **众卿 Retinue 用来干什么?**
  365. 把工作派给人和 AI agent 组成的混合团队,在一块自托管看板上执行,并留下可核
  366. 验的记录:谁握过这张卡、声称做了什么、验收条件是否真的通过。
  367. **支持 Claude Code、Codex 和其他 MCP 客户端吗?**
  368. 支持。MCP agent 通过 `retinue-server mcp` 接入;不支持 MCP 的用 HTTP 接口加
  369. 受限 actor 令牌。Claude Code 和 Codex 另有只读会话 exporter 统计 token。
  370. **它是开源软件吗?**
  371. 是,当前源码采用 **AGPL-3.0-only**,遵守 AGPL 可免费商用,也可另购商业授权。
  372. 详见 [LICENSE](LICENSE) 和 [COMMERCIAL.md](COMMERCIAL.md)。
  373. **会把我的数据传到哪里去吗?**
  374. 不会。没有遥测、没有托管控制面、没有远程账号、没有强制外呼。核心、面板、
  375. daemon、demo、exporter 全部可离线运行。只有你显式配置的 IM 适配器会外联。
  376. **可以部署在 homelab 或 NAS 上吗?**
  377. 可以。`docker compose up --build` 起一个端口即可;下面的十分钟走廊全程走回
  378. 环。暴露风险与备份见 [`SELF_HOSTING.md`](SELF_HOSTING.md)。
  379. **和 Vibe Kanban 这类 AI kanban 有什么不同?**
  380. 众卿是「看板 + 审计边界」。agent 被当作不可信执行者:它永远不能指定要跑的
  381. hook(hook 只来自运营者的 `org.yaml`)、写权限只归持有人、回执链只增不改。
  382. 看板本身就是治理面,不只是任务队列。
  383. **必须用 Docker 吗?**
  384. 不必。无 Docker 的文件总线走廊见
  385. [`docs/closed-loop-walkthrough.md`](docs/closed-loop-walkthrough.md)。
  386. ## 许可证
  387. Copyright (c) 2026 JKL Thinking。当前源码树采用 **AGPL-3.0-only**,
  388. 同时提供单独的商业授权。
  389. - 个人和公司内部使用都免费,包括商用。
  390. - 修改后通过网络对外提供服务,必须按 AGPL 向这些用户提供修改版本的对应源码。
  391. - 不想履行这些要求,可以购买商业授权。
  392. 联系邮箱:[jklthinking@foxmail.com](mailto:jklthinking@foxmail.com)。
  393. - **已按 MIT 发布的 0.3.0a4 及以前版本永远是 MIT,不追溯。**
  394. 分发和其他使用场景也须履行适用的 AGPL 条款。此说明针对该分界后的开发源码,
  395. 不改写旧发行版或标签。详见 [LICENSE](LICENSE)、[NOTICE](NOTICE)、
  396. [商业授权](COMMERCIAL.md)、[贡献者协议](CLA.md) 和 [商标说明](TRADEMARKS.md)。
  397. 第三方依赖继续遵循各自许可证,声明见
  398. [THIRD_PARTY_NOTICES](docs/THIRD_PARTY_NOTICES.md)。
  399. ## 社区
  400. RETINUE 在 [LINUX DO](https://linux.do) 社区发布与交流,欢迎在 GitHub 提交 issue 与 PR。

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.