NX

從 Chat 到 Cowork：為你的 Go 後端加入文件夾驅動的 Agentic 工作流

🛠️ 开发者实操 x/dev-workshop ·
從 Chat 到 Cowork：為你的 Go 後端加入文件夾驅動的 Agentic 工作流

Chat to Cowork

不是又一個 AI 聊天機器人。這是一份從 Claude Cowork 中提煉出的實戰架構指南——教你如何讓 LLM Agent 從「對話夥伴」進化為「團隊成員」。本文已更新為 coworkspace 命名規範，避免與現有 workspaces 基礎設施衝突。

為什麼要從 Chat 走向 Cowork？

Rahul 最近在 X 上發了一條爆文——"How To Build a One-Person Company Using Claude Cowork"，短短幾小時就超過 85 萬次觀看。他點出了一個關鍵事實：

知識工作者每天花 60% 的時間在格式化、整理檔案、撰寫報告、研究、SEO——這些工作不需要深度思考，但它們佔據了我們大部分的時間。

Chat 模式的 AI 很有用，但它有一個根本限制：你必須全程在迴圈裡。每一個動作都需要你的下一句 prompt。這是協作，不是委派。

Claude Cowork 改變了這個模式。它的核心洞察是：把 Claude Code 的 agentic 引擎包裝成 GUI，讓非技術使用者也能委派完整任務。

但如果你是一位開發者，你需要的不是「如何使用 Claude Cowork」，而是——如何在自己的 Go 後端中實現同樣的架構。

這篇文章就是你的實作指南。

Claude Cowork 教我們的五個核心設計模式

深入研究 Cowork 的架構後，我提煉出五個可以遷移到任何後端系統的關鍵模式：

1. 以「成果」而非「Prompt」為中心

傳統 Chat：使用者拆解問題 → 逐句 prompt → AI 逐句回應
Cowork 模式：使用者描述想要的結果 → AI 自主規劃 → 執行 → 交付成品

// 傳統 Chat API
POST /api/chat { "message": "幫我整理 Downloads 資料夾" }

// Cowork API（使用 coworkspace slug 而非 ID）
POST /api/cowork/tasks {
  "outcome": "整理 Downloads 資料夾，按類型和日期分類，並從收據中生成一份費用報表",
  "coworkspace_slug": "downloads-organizer"
}

2. 工作區 = 文件夾（使用 slug 命名）

在 Cowork 中，每個任務都有一個對應的資料夾。檔案是人類和 Agent 之間的交換媒介。Agent 讀取檔案、處理、寫入新檔案——使用者回來時看到的是成品。

為什麼使用 coworkspaces 而非 workspaces？ 如果程式碼庫中已經有 workspaces 目錄或概念，coworkspaces 可以完全避免命名衝突。同時，使用 slug（如 downloads-organizer）而非不透明的 ID，讓資料夾對人類和 Agent 都具可讀性——你的檔案系統就是自帶文檔。

/coworkspaces/{slug}/
├── .instructions.md     ← 專案指令（claude.md 等價物）
├── .memory/             ← Agent 記憶（跨 session 持久化）
├── .plan.json           ← 當前任務計畫
├── files/               ← 使用者檔案
├── output/              ← Agent 生成的交付物
└── .locks/              ← 檔案鎖（防止並發衝突）

3. 先計畫，後執行

Agent 不是直接開始工作。它先生成一個可見的計畫：

{
  "summary": "整理 Downloads 並生成費用報表",
  "phases": [
    {
      "name": "掃描與分類",
      "description": "掃描所有檔案，按類型分類",
      "subtasks": ["列出所有檔案", "按副檔名分組", "建立分類資料夾"],
      "parallel": false
    },
    {
      "name": "並行處理",
      "description": "同時處理不同類型的檔案",
      "subtasks": ["處理收據 PDF", "整理圖片", "歸檔文件"],
      "parallel": true
    },
    {
      "name": "生成報表",
      "description": "從收據中提取數據並生成報表",
      "subtasks": ["OCR 收據", "提取金額和日期", "生成 Excel 報表"],
      "parallel": false,
      "depends_on": ["並行處理"]
    }
  ]
}

使用者可以在執行前審查和修改這個計畫。這就是透明的自主執行。

4. 子 Agent 並行擴展（Fan-Out）

複雜任務不是一個 Agent 從頭跑到尾。它會根據計畫的 parallel: true 階段，同時啟動多個子 Agent：

主 Agent（Orchestrator）
  ├── Agent A: 處理收據 PDF
  ├── Agent B: 整理圖片檔案  
  ├── Agent C: 歸檔文件檔案
  └── Agent D: 去重和清理
  
  全部完成後 →
  主 Agent 綜合結果 → 生成最終交付物

每個子 Agent 有自己的 context window，通過檔案鎖來協調任務分配。關鍵是：子 Agent 之間通過檔案和訊息溝通，而非共享記憶體——這樣才能避免 context 污染。

5. 檢查點機制支援長時間運行

Cowork 任務可能執行幾分鐘到幾小時。必須在每個 turn 保存狀態：

type TaskCheckpoint struct {
    TaskID       string             `json:"task_id"`
    Turn         int                `json:"turn"`
    AgentStates  []AgentSnapshot    `json:"agent_states"`
    PlanProgress map[string]float64 `json:"plan_progress"`
    SavedAt      time.Time          `json:"saved_at"`
}

伺服器重啟？任務從最後一個 checkpoint 恢復。這是 Cowork 和 Chat 的本質區別——Chat 斷了就要重來，Cowork 斷了可以繼續。

Go 後端架構：從 Chat 到 Chat + Cowork

你現有的基礎設施

好消息是，你現有的 Go 後端已經有了大部分基礎：

現有功能 Cowork 對應
Chat Cowork Task（指派結果而非對話）
Goals Task Plan（可視化的待辦清單）
Files-based project Coworkspace（每個任務的持久化文件夾）
Direct tasks (async) Agent Loop（自主多步執行）
Schedules Scheduled Cowork Tasks（定時 + 手動觸發）

需要新增的核心服務（全部使用 coworkspace 前綴）

// 1. CoworkOrchestrator — 任務生命週期管理
type CoworkOrchestrator interface {
    CreateTask(ctx, outcome, coworkspaceSlug, opts) (*CoworkTask, error)
    StartTask(ctx, taskID) error
    GeneratePlan(ctx, taskID) (*TaskPlan, error)
    GetTaskProgress(ctx, taskID) (*TaskProgress, error)
}

// 2. AgentLoop — 自主執行引擎
type AgentLoop interface {
    ExecuteTurn(ctx, agentID) (*TurnResult, error)
    ExecuteUntilDone(ctx, agentID, opts) error
}

// 3. SubAgentOrchestrator — 並行子 Agent 管理
type SubAgentOrchestrator interface {
    FanOut(ctx, taskID, specs) ([]SubAgent, error)
    ClaimTask(ctx, taskID, subtaskID, agentID) error  // 檔案鎖
    SynthesizeResults(ctx, taskID) (*SynthesisResult, error)
}

// 4. CoworkspaceManager — 文件夾工作區管理（已重新命名）
type CoworkspaceManager interface {
    CreateCoworkspace(ctx, name, opts) (*Coworkspace, error)
    ReadFile(ctx, coworkspaceSlug, path) ([]byte, error)
    WriteFile(ctx, coworkspaceSlug, path, content) error
}

Agent Loop — 系統的核心

Agent Loop 是整個 Cowork 系統的心臟。它是一個狀態機，把「我想要 X」變成一系列的 LLM 驅動動作：

LOOP:
  1. 構建 Prompt（任務 + 計畫 + 當前狀態 + 可用工具）
  2. 呼叫 LLM → 取得 Thought + Tool Calls
  3. 審批閘門（高風險操作需要使用者確認）
  4. 執行工具（讀檔、寫檔、搜索、生成...）
  5. 將結果餵回 Agent
  6. 檢查終止條件：done / wait_for_user / continue
  7. 保存 Checkpoint
GOTO LOOP

核心 Tool Registry：

var CoreCoworkTools = []Tool{
    FileReadTool{},           // 讀取 coworkspace 檔案
    FileWriteTool{},          // 寫入檔案
    FileListTool{},           // 列出目錄
    WebSearchTool{},          // 網路搜索
    WebFetchTool{},           // 擷取 URL 內容
    ShellTool{},              // 在隔離沙箱中執行指令
    SubAgentSpawnTool{},      // 啟動子 Agent
    SubAgentMessageTool{},    // Agent 間通訊
    MemoryStoreTool{},        // 儲存到 coworkspace 記憶
    MemoryRetrieveTool{},     // 從 coworkspace 記憶檢索
    TaskUpdateTool{},         // 更新任務計畫
    DeliverableCreateTool{},  // 建立交付物
}

漸進式遷移路徑

不需要推倒重來。Cowork 是 Chat 的補充，不是替代：

Phase 1：基礎（第 1-2 週）

  • 實作 CoworkspaceManager + 檔案 CRUD，路徑為 /coworkspaces/{slug}/
  • 新增 CoworkTask 資料模型和 API
  • 加入 .instructions.md 支援

Phase 2：Agent Loop（第 3-4 週）

  • LLM + Tool Calling 整合
  • Agent Loop 逐回合執行
  • 計畫生成 + 審批閘門

Phase 3：並行編排（第 5-6 週）

  • 子 Agent 生成與管理
  • 檔案鎖任務分配
  • Agent 間通訊 + 結果綜合

Phase 4：打磨（第 7-8 週）

  • SSE 即時進度推送
  • 與現有 Schedules 系統整合
  • Checkpoint / 恢復機制

整個過程中，原有的 Chat API 完全不受影響，使用者可以同時使用兩種模式。

資料庫 Schema（全部以 coworkspace_ / cowork_ 為前綴）

-- Coworkspaces（基於 slug 而非 ID）
CREATE TABLE coworkspaces (
    slug          TEXT PRIMARY KEY,       -- e.g., "downloads-organizer"
    name          TEXT NOT NULL,
    root_path     TEXT NOT NULL,
    instructions  TEXT,                   -- .instructions.md 內容
    project_id    TEXT,
    user_id       TEXT NOT NULL,
    created_at    TIMESTAMP DEFAULT NOW()
);

-- Cowork 任務
CREATE TABLE cowork_tasks (
    id                TEXT PRIMARY KEY,
    coworkspace_slug  TEXT NOT NULL REFERENCES coworkspaces(slug),
    outcome           TEXT NOT NULL,       -- 使用者想要的結果
    status            TEXT NOT NULL DEFAULT 'pending',
    plan_json         JSONB,
    permission_mode   TEXT NOT NULL DEFAULT 'ask_before'
);

-- 任務階段
CREATE TABLE task_phases (
    id         TEXT PRIMARY KEY,
    task_id    TEXT NOT NULL REFERENCES cowork_tasks(id),
    name       TEXT NOT NULL,
    status     TEXT NOT NULL DEFAULT 'pending',
    parallel   BOOLEAN DEFAULT FALSE,
    depends_on JSONB,
    progress   REAL DEFAULT 0.0
);

-- 子 Agent
CREATE TABLE sub_agents (
    id      TEXT PRIMARY KEY,
    task_id TEXT NOT NULL REFERENCES cowork_tasks(id),
    name    TEXT NOT NULL,
    role    TEXT NOT NULL,
    status  TEXT NOT NULL DEFAULT 'idle'
);

-- Agent 間訊息
CREATE TABLE agent_messages (
    id         TEXT PRIMARY KEY,
    from_agent TEXT NOT NULL,
    to_agent   TEXT NOT NULL,
    type       TEXT NOT NULL,
    content    TEXT NOT NULL
);

-- 檢查點（支援斷點續傳）
CREATE TABLE task_checkpoints (
    id         TEXT PRIMARY KEY,
    task_id    TEXT NOT NULL REFERENCES cowork_tasks(id),
    turn       INTEGER NOT NULL,
    state_json JSONB NOT NULL
);

-- 索引
CREATE INDEX idx_cowork_tasks_coworkspace ON cowork_tasks(coworkspace_slug);
CREATE INDEX idx_cowork_tasks_status ON cowork_tasks(status);
CREATE INDEX idx_phases_task ON task_phases(task_id);
CREATE INDEX idx_agents_task ON sub_agents(task_id);
CREATE INDEX idx_checkpoints_task ON task_checkpoints(task_id, turn DESC);

關鍵設計決策

決策 理由
Coworkspace = 文件夾 檔案是人與 Agent 最自然的交換媒介，也是 Claude Cowork 的核心哲學
Slug 路由 人類可讀路徑（/coworkspaces/downloads-organizer/），不再使用不透明 ID
coworkspaces 目錄 避免與程式碼庫中現有 workspaces 命名衝突
cowork_* / coworkspace_* 前綴 所有資料表、函數和路由使用清晰的命名空間隔離
先計畫後執行 透明性 + 使用者可在執行前修正方向
子 Agent 可棄用 各自獨立 context，通過檔案溝通，避免 context 污染
每個 turn 保存 checkpoint 支援長時間任務，伺服器重啟不丟失進度
審批閘門可配置 ask_before（安全）vs act_autonomously（快速），檔案刪除永遠需要確認
Chat 不變 Cowork 是加法，不是替代——用對的工具做對的事

總結

Claude Cowork 的出現不代表你需要換掉你的後端。它代表的是一種架構思想的轉變：

  • 從「我告訴 AI 每一步做什麼」到「我告訴 AI 我要什麼結果」
  • 從「對話框」到「文件夾」
  • 從「單一 Agent」到「Agent 團隊」
  • 從「同步等待」到「非同步委派」

你現有的 Go 後端已經有了 Chat、Schedules、Goals、Files、Direct Tasks——這些都是 Cowork 模式的絕佳基礎。加上 Agent Loop、Sub-Agent Orchestrator、和 Coworkspace 管理，你就能讓 LLM Agent 從一個被動的對話夥伴，變成一個真正能獨立完成工作的團隊成員。

參考資料：

Back to 🛠️ 开发者实操
·