從 Roo Code 到 Opencode：當 AI 工具開始不只是寫程式

公司最近又換 AI coding tool 了，我怎麼會說又呢，因為 Opencode 太好用啦，絕對不是 Roo Code Sunset 了。

一開始我沒辦法理解工具一直換但最後不是都是在解決問題和產生程式碼嗎？

我原本以為差異只是：

• Opencode 是 Multi-Agent 架構
• Roo Code 是 Single-Agent 架構

以及

• Opencode 是 CLI based
• Roo Code 是 VS Code extension

但，真的只有這樣嗎？

先來回顧一下一路走來我們怎麼使用這些工具的

把近幾年的工具發展大致分成幾個階段。

Before AI 時代

代表工具：

• Jedi, Pylance, IntelliSense

工作模式：

Developer
    ↓
敲鍵盤，tab、tab、tab
    ↓
補 function name

這邊只能做到基本的程式碼補齊、Go to Definition 之類現代 IDE 的基本功能。

第一階段：Code Completion

代表工具：

• GitHub Copilot
• Tabnine

工作模式：

Developer
    ↓
Copilot
    ↓
補程式碼

這個階段 AI 工具的工作就是根據上下文，把剩下的程式碼補齊。

第二階段：Coding Agent

代表工具：

• Cursor
• Gemini Code Assist
• Roo Code
• 現在的 Copilot

工作模式：

Developer
    ↓
Roo Code
    ↓
分析專案
    ↓
修改專案

這個階段的 AI 工具不只能補全程式碼，它還可以：

• 閱讀專案
• 分析架構
• 修改多個檔案
• 提出建議
• 執行測試
• 修正錯誤

這個時期的 AI 已經是個稱職的輔助駕駛了。

第三階段：Agent Runtime

代表工具：

• Opencode
• Claude Code
• Codex CLI
• Pi Agent

工作模式：

Developer
    ↓
Opencode
    ↓
Task Decomposition
    ↓
Tool / Agent Orchestration
    ↓
Validated Output

這個時候的用法已經不是只能在 VS Code 中下一句 prompt 說：「幫我實作某某功能」，而是 「某某 team 想要在 Snowflake 下開立新的 table，你幫他跑完所有流程」

那 Roo Code 和 Opencode 到底有什麼區別？

要我來總結的話我會說處理的問題不同，Roo Code 這種 Coding 工具是偏向給開發者使用，通常會和 IDE 整合，但 Opencode 這種 Agent 則把能處理的事情往上提升一個層級，透過 MCP 或是 A2A Opencode 能做到不只是 「Coding」 這件事。

舉例來說，我可以靠 Opencode 組織一個開發團隊，裡面包含 PM、設計師、SA、SWE、QA 等等，交辦任務後就讓這個團隊去完成工作了。

另一個例子是假設今天我是 DevOps 遇到了 GKE 網路問題，我可以同時指派 Network agent、GKE agent、GCP agent 同時下去查問題，這個就會比 Roo Code 透過一次次來回蒐集線索然後決定下一步還會快速。

Multi-agent vs Single-agent runtime

我們可以從 Roo Code 的原始碼來看看它是怎麼建立 subtasks 的 (下面的 Code 都有簡化過)

export class NewTaskTool extends BaseTool<"new_task"> {
	async execute(params: NewTaskParams, task: Task, callbacks: ToolCallbacks): Promise<void> {
		const { mode, message, todos } = params

		if (!mode || !message) {
			return
		}

		const targetMode = getModeBySlug(mode, state?.customModes)
		if (!targetMode) {
			pushToolResult(formatResponse.toolError(`Invalid mode: ${mode}`))
			return
		}

		const toolMessage = JSON.stringify({
			tool: "newTask",
			mode: targetMode.name,        // ← 指定 mode
			content: message,             // ← Context 內容
			todos: todoItems,             // ← 初始 todo
		})

		const didApprove = await askApproval("tool", toolMessage)
		if (!didApprove) return

		const child = await provider.delegateParentAndOpenChild({
			parentTaskId: task.taskId,
			message: unescapedMessage,
			initialTodos: todoItems,
			mode,
		})

		pushToolResult(`Delegated to child task ${child.taskId}`)
	}
}

可以看到 Roo Code 雖然可以作 orchestration 建立 subtask，但是它建立的是 child task，不是另一個可獨立配置的 subagent，而是把需要用到的 Mode, Todo 以及 Context 傳遞下去。

而 Opencode 是用兩步驟來建立 subagent

建立新的 session

const nextSession =
  session ??
  (yield* sessions.create({
    parentID: ctx.sessionID,
    title: params.description + ` (@${next.name} subagent)`,
    agent: next.name,
    permission: [
      ...deriveSubagentSessionPermission({
        parentSessionPermission: parent.permission ?? [],
        parentAgent,
        subagent: next,
      }),
      ...(cfg.experimental?.primary_tools?.map((item) => ({
        pattern: "*",
        action: "allow" as const,
        permission: item,
      })) ?? []),
    ],
  }))

建立 subagent

const runTask = Effect.fn("TaskTool.runTask")(function* () {
  const parts = yield* ops.resolvePromptParts(params.prompt)  // 解析 prompt 中的參數
  const result = yield* ops.prompt({
    messageID: MessageID.ascending(),
    sessionID: nextSession.id,  // ← 傳給新 subagent 的 session
    model: {
      modelID: model.modelID,
      providerID: model.providerID,
    },
    variant: next.model ? undefined : variant,
    agent: next.name,
    tools: {
      ...(next.permission.some((rule) => rule.permission === "todowrite") ? {} : { todowrite: false }),
      ...(next.permission.some((rule) => rule.permission === id) ? {} : { task: false }),
      ...Object.fromEntries((cfg.experimental?.primary_tools ?? []).map((item) => [item, false])),
    },
    parts,  // ← 傳遞 prompt 內容（context/task）
  })
  return result.parts.findLast((item) => item.type === "text")?.text ?? ""
})

這兩種執行方式不單單只是多工及速度上的差異，首先來談談 Roo 這樣作有什麼優缺點。

Roo 的作法是使用單一 Agent 搭配不同的 Mode 來做到角色切換。它的 runtime 比較像 task stack 模型，parent task 會暫停，child task 被 push 到 stack top 成為 active task，完成後再回到 parent task，所以一次主要只有一個 task 或 subtask 在推進。我們用起來有時候會覺得 Roo 在執行階段非常慢，但這樣的設計還是可以帶來一些好處:

1. 一次只執行一個 task，使用者可以持續關注當前的 task，隨時介入
2. 不用處理 Race condition 問題
3. 執行是線性的，要 debug 會比較容易

另一方面 Opencode 採用 multi-agent 的設計，可以設計成多個 subagent 平行執行。除了效率外，agent 的客製化會是一個決定性的區別，在 Opencode 中我們可以自己定義 agent 的 workflow、有哪些權限以及工具可以使用，這樣使用 Opencode 這種工具能做到事情從 「hey, 幫我開發這個功能」 進化到 「hey, 幫我解決這個問題」。

為什麼新一代工具開始回到 CLI？

我的看法是，如同前面提到的工具進化，現在 AI 工具能做到的不再只是 Coding 而已，所以跳脫 IDE 的設計勢在必行。IDE 是程式碼的工作空間而 Terminal 是系統的工作空間，擁有系統的權限意味著 agent 能夠為你服務更多事情。

Roo 與 Opencode 的核心差異

最後總結：

Roo Code	Opencode
IDE First	Agent First
Code-centric	Work-centric
Single active task	Agent orchestration
Context Continuity 強	Task Decomposition 強
適合個人開發	適合複雜工作流