作者: kerwin77106

  • 用 goose AI Agent 開一隻全能小幫手

    用 goose AI Agent 開一隻全能小幫手

    📌 本文重點

    • goose 是用 Rust 寫的開源 AI Agent 框架
    • 讓 LLM 真的能跑指令、改檔案、寫測試而不只聊天
    • 可接任意 LLM,並透過 workflow 自動化多步驟任務
    • 很適合 DevOps / 開發者做日常開發與部署自動化

    用一句話說清楚:goose 是一個用 Rust 寫的開源 AI Agent 框架,可以讓 LLM 不只聊天,而是真的幫你在電腦上安裝套件、跑指令、改程式碼、寫測試,變成一個可以自動執行任務的「全能小幫手」。

    GitHub 專案:https://github.com/aaif-goose/goose


    goose 和一般聊天機器人有什麼不同?

    一般 ChatGPT / Claude 類工具,多半停在「給你建議」:

    • 產生程式碼片段
    • 幫你想測試案例
    • 告訴你下一步可以怎麼做

    goose 的差別在於:它可以自己動手做。

    透過 goose,你可以讓模型:

    • 在你的環境裡 執行殼層指令(shell commands)
    • 直接修改專案檔案、重構程式碼
    • 跑測試、根據結果再修正
    • 用 plugin / tool 的形式接上你自己的 API 或腳本

    換句話說,它比較像一個「可編程的 AI 工具人」,而不是純聊天機器人。

    💡 關鍵: goose 不只回覆文字,而是能在你的實際環境中「讀檔案、下指令、改程式」,真正把建議變成動作。


    核心功能:你可以拿 goose 來做什麼?

    1. 調用殼層指令:讓 LLM 幫你按命令行上的按鈕

    goose 內建「可以執行 shell 指令」的能力。

    你可以叫 agent 做這些事:

    • 安裝套件:apt-get, brew, pip, cargo…
    • 拉專案:git clone、切分支、pull 最新版
    • 跑工具:npm test、cargo test、pytest、make build

    你要做的行動:

    • 想一件你平常常打的一串指令(例如部署前要跑的 3–5 個步驟)
    • 把它寫成一句自然語言任務,交給 goose,觀察它如何自己拆解並下指令

    2. 程式碼編輯與測試:真的會改你專案的那種

    goose 支援對檔案系統操作,讓 LLM 直接:

    • 開啟 / 讀取專案中的檔案
    • 修改檔案內容(插入、刪除、重構)
    • 新增測試檔、更新 README

    常見用法:

    • 讓 agent 自動幫你 加 log / exception handling
    • 要它針對某個 module 補齊單元測試
    • 改 config、更新版本號、調整 CI 設定檔

    你要做的行動:

    • 選一個「可以放心被 AI 改壞」的小 side project
    • 用 goose 給它一個任務,例如:「在這個 Rust 專案裡,新增一個 health check endpoint,並幫我補上測試」

    3. 自訂工具擴充:把你自己的腳本、API 變成 agent 的能力

    goose 的設計重點是 「可擴充的工具」。你可以:

    • 把現有的 Python / Bash 腳本包裝成一個 tool
    • 把團隊內部 API(如 issue tracker、部署服務)接進來
    • 讓 agent 用「呼叫工具」的方式,連續完成更複雜的流程

    實際效果:

    • LLM 不用自己「想像」怎麼部署,而是呼叫你提供的 deploy_api
    • 你可以限制它只能用你認可的工具,控制風險

    你要做的行動:

    • 列出你工作中最常手動跑的 2–3 個腳本
    • 想像它們如果變成一個 deploy_service / create_release 的工具,agent 可以怎麼自動串起來

    4. 接任意 LLM:OpenAI、DeepSeek、本地模型都行

    goose 標榜 「with any LLM」,實際上就是可以在設定中自由切換 backend:

    • OpenAI(如 gpt-4.1)
    • DeepSeek API(如 deepseek-coder)
    • 透過 OpenAI-compatible API 的本地模型(Ollama、LM Studio…)

    這讓你可以:

    • 開發時用免費 / 便宜模型測試流程
    • 上線到正式環境時再換成更穩定的雲端模型

    你要做的行動:

    • 先挑一個你現有就有 API Key 的 LLM(例如 OpenAI 或 DeepSeek)
    • 決定:
    • 「實驗階段」用哪個模型
    • 「正式跑自動化」時要不要升級到較貴的模型

    💡 關鍵: 透過切換 GOOSE_MODEL 等設定,你可以在成本(本地 / 便宜模型)與效果(雲端高階模型)之間彈性取捨。


    適合誰用?三種典型場景

    1. DevOps/SRE:日常腳本自動化

    例如:

    • 部署前:拉最新程式碼 → 跑測試 → build → health check
    • 緊急修補:切 branch → 套 patch → 跑 smoke test → 發一版 hotfix

    用 goose 的做法:

    • 把這些步驟包成一個「任務腳本」(workflow)
    • 讓 agent 自己決定下一步要跑哪個指令、根據輸出結果調整

    2. 開發者:專案 boilerplate 生成與重構

    適用情境:

    • 開一個新服務:想要快速產生「專案骨架 + 基本路由 + CI 檔案」
    • 老專案:想系統性把某種寫法換成新的 pattern

    用 goose 可以這樣玩:

    • 指定專案資料夾給 agent
    • 給一個任務:「初始化一個 NestJS API 專案,幫我加上 Dockerfile 和 GitHub Actions CI」

    3. 團隊工程流程:CI 前自動檢查與修修補補

    在 CI 跑之前,先讓 goose 幫你:

    • 檢查程式格式、lint 問題
    • 嘗試自動修正簡單的錯誤
    • 對 PR 產生簡短變更說明

    做法:

    • 在 CI pipeline 裡加入「goose agent 步驟」
    • 給它權限在 CI runner 上修改檔案並 push(或開新 PR)

    💡 關鍵: 把 goose 放進 CI / pre-commit,可以在錯誤進到主線分支之前,自動完成一輪整理與簡單修補。


    怎麼開始:最快速的上手路徑

    1. 用 Docker 跑起官方範例(最快測試)

    前提:

    • 已安裝 Docker
    • 手邊有一個 LLM API Key(例:OPENAI_API_KEY)

    步驟:

    # 1. 拉專案
    git clone https://github.com/aaif-goose/goose.git
    cd goose
    
    # 2. 建一個 .env,放你的模型設定(簡化示意)
    cat << 'EOF' > .env
    OPENAI_API_KEY=your_key_here
    GOOSE_MODEL=openai/gpt-4.1
    EOF
    
    # 3. 用 docker compose 跑起來(實際以 repo 裡的 compose 指令為準)
    docker compose up --build
    

    跑起來後,通常會有:

    • 一個 CLI / HTTP 介面
    • 你可以丟:
    • 「在這個容器裡安裝 curl 並測試對 google.com 發送請求」

    行動建議:先在容器內做「無害」的事情,例如安裝一個套件、建立一個測試檔案,確認 goose 真的有在動你環境。


    2. 本機安裝(Rust 使用者)

    前提:

    • Rust toolchain(rustup)

    步驟:

    # 1. 安裝依賴
    cargo install --path .  # 實際請以 README 為準
    
    # 2. 設定環境變數
    export OPENAI_API_KEY=your_key_here
    export GOOSE_MODEL=openai/gpt-4.1
    
    # 3. 跑 CLI
    goose run
    

    你可以在終端機裡對 agent 下指令,例如:

    • 「列出目前資料夾的檔案,幫我找出所有含有 TODO 的檔案並列出行號」

    3. 接上常見模型(OpenAI / DeepSeek / 本地 LLM)

    以下是假設性的設定方向(實際請對照 goose README):

    OpenAI

    export OPENAI_API_KEY=your_key
    export GOOSE_MODEL=openai/gpt-4.1
    

    DeepSeek

    通常會提供 OpenAI 相容 API:

    export OPENAI_BASE_URL=https://api.deepseek.com/v1
    export OPENAI_API_KEY=your_deepseek_key
    export GOOSE_MODEL=deepseek-chat
    

    本地 LLM(以 Ollama 為例)

    啟動 Ollama 後:

    export OPENAI_BASE_URL=http://127.0.0.1:11434/v1
    export OPENAI_API_KEY=dummy
    export GOOSE_MODEL=ollama/llama3.1
    

    行動建議:先用最簡單、你現在就有的 API Key 接上,確認 goose 的流程跑得通,再考慮搬到本地模型節省成本。


    寫一個自己的「任務腳本」:讓 agent 連續完成幾個步驟

    goose 的強項在於可以定義「多步驟任務」。概念上,你會有一個 workflow 設定(格式依官方為準,這裡用 pseudo-code 示意):

    # workflows/dev_check.toml
    name = "dev_precommit_check"
    
    [[steps]]
    type = "shell"
    command = "git status"
    
    [[steps]]
    type = "agent"
    prompt = "閱讀 git status,決定要先格式化哪一些檔案,並執行對應指令。"
    
    [[steps]]
    type = "shell"
    command = "cargo test"
    
    [[steps]]
    type = "agent"
    prompt = "根據測試結果,如果有簡單錯誤可以直接修,並再次執行對應測試。"
    

    用法:

    goose run-workflow workflows/dev_check.toml
    

    這樣,你可以一行命令啟動一個「會看情況調整動作」的前置檢查流程。

    你要做的行動:

    • 先定義一個超簡單的 workflow:
    • Step1:ls 專案
    • Step2:請 agent 根據專案結構生成一段簡短說明,寫入 PROJECT_SUMMARY.md

    實戰:從零做一個小型自動化 workflow

    目標:在一個現有專案裡,做「提交前自動整理 + 簡單修補」流程。

    我們要達成:

    1. 檢查目前分支變更檔案
    2. 對變更檔案跑 formatter / linter
    3. 如果有明顯錯誤,由 agent 嘗試自動修改
    4. 重新跑測試

    Step 1:準備專案與權限

    1. 找一個你熟悉、可以接受被改動的專案資料夾
    2. 新開一個分支,如 feat/goose-auto-fix
    3. 確保 goose 有權限:
    4. 讀寫這個資料夾
    5. 執行必要的指令(例:npm test、cargo test)

    Step 2:定義 workflow(示意)

    依 goose 支援的格式建立一個 workflow 檔(假設是 YAML):

    name: precommit-helper
    steps:
      - type: shell
        command: git diff --name-only
      - type: agent
        prompt: |
          你看到的是目前分支有變更的檔案清單。
          目標:
          1. 對這些檔案執行合適的 formatter / linter 指令(依照檔案類型判斷)。
          2. 若 formatter/linter 回報可自動修復的問題,請修改檔案並重新執行檢查。
      - type: shell
        command: npm test  # 或你專案的測試指令
      - type: agent
        prompt: |
          根據測試輸出,
          - 若是小型邏輯/型別錯誤,嘗試修改相關檔案後再次執行測試。
          - 若錯誤較複雜,請產生簡短說明寫入 precommit_report.md。
    

    Step 3:實際執行與調整

    1. 在專案根目錄跑:

    bash
    goose run-workflow precommit-helper.yaml

    1. 觀察它的行為:
    2. 有沒有亂跑你不想要的指令?
    3. 修改的檔案是否合理?

    4. 根據結果調整:

    5. 限制能用的指令範圍(例如只允許 npm test, npm run lint)
    6. 在 prompt 裡多加一些「安全護欄」,例如「不要刪除檔案」。

    完成後,你就有了一個:

    • 可以在提交前幫你「整理 + 修補 + 產生報告」的小型 AI 助理
    • 海豚式改進:遇到痛點就稍微改一下 workflow / 工具清單,越用越貼近你團隊習慣

    小結:下一步可以怎麼玩?

    如果你看到這裡,建議接下來這樣走:

    1. 先跑官方範例容器一次,確認 goose 在你機器上可以正常跑指令。
    2. 選一個專案資料夾,做一個超小 workflow:只做檔案摘要或自動補 README。
    3. 把你現有的一個腳本包成 tool,讓 agent 可以呼叫(例如部署或打包腳本)。
    4. 等你有信心後,再把它接進 CI / pre-commit 流程。

    完整專案與最新用法請看:https://github.com/aaif-goose/goose

    把 goose 想成一個「可編程的 ChatGPT + 指令列機器人」,先從最小、風險最低的自動化開始,你會很快找到適合自己工作流的用法。

    🚀 你現在可以做的事

    • 打開 <https://github.com/aaif-goose/goose>,用 Docker 照著 README 跑一次官方範例
    • 選一個 side project,讓 goose 幫你完成「新增一個 endpoint + 補上測試」的小任務
    • 把日常最常用的一個部署或檢查腳本包成 tool,寫一個只包含 2–3 個步驟的簡單 workflow
  • OpenAI 變身顧問公司,是升級還是掠奪?

    OpenAI 變身顧問公司,是升級還是掠奪?

    📌 本文重點

    • 模型公司正下沉吃下「部署層+顧問層」
    • 雲端、SI、傳統顧問的話語權被擠壓
    • 企業短期加速,長期恐被 AI 供應商鎖死
    • 技術人需保留多模型與技術主權

    當 OpenAI 拉來超過 40 億美元 成立 「The Deployment Company」,而 Anthropic 則與 Goldman Sachs、Blackstone、Hellman & Friedman 合資開企業 AI 公司,真正訊號不是「AI 很熱」,而是:光有 SOTA 模型賣不動,他們決定連「部署層+顧問層」一起吃下來。 對產品與技術領導者來說,這不是一個新工具的發布,而是一場產業結構改寫的開端。


    一、為什麼模型巨頭同時變身「顧問公司」?

    表面上,The Deployment Company 和 Anthropic 新創是「幫企業導入 AI」。但從資本結構與合作對象看,本質是:模型公司往下整合到最後一公里的變革工程。

    • OpenAI:募資 >40 億美元,專門做企業部署,從銷售、方案設計到落地運維一條龍,直接瞄準大企業預算盤。
    • Anthropic:不是自己養一支龐大顧問隊,而是與 華爾街私募+系統整合商 成立新公司,先吃 中型企業 的 Claude 導入需求。
    • 同一時間,雲端三巨頭的 AI 帶動雲收入爆衝:Google Cloud +63%、Azure +40%、AWS +28%,而頂尖模型公司對雲的承諾層級動輒百億甚至 Anthropic 對 Google Cloud 的 2000 億美元五年承諾,把整個故事鎖定在「算力+部署」雙重賭注。

    💡 關鍵: 從「>40 億募資」到「2000 億承諾」,顯示資本已從單買模型,轉向重押「算力+部署一體化」的變革工廠。

    這裡有三個關鍵認知轉向:

    1. 模型不再是產品,而是原料。
      企業買的不是「一個 API」,而是「能讓組織 KPI 動起來的變革專案」。模型只是原料,真正能開票的是顧問方法論+成功案例庫。

    2. 銷售 AI 的瓶頸,不在演算法,而在組織。
      很多企業 CTO 的真實痛點是:合規、流程重設、權限治理、舊系統整合、員工再訓練——這些全部是「部署層」問題,傳統模型供應商不碰,現在 OpenAI/Anthropic 決定親自下場。

    3. 資本不再只買參數量,而是買「變革工廠」。
      Blackstone、Goldman Sachs 這些玩家進來,不是因為愛 AI,而是看到:如果能把「導入 AI」變成一套可複製、可擴展的工廠流程,就可以在投資組合公司裡批量複製生產力提升與成本削減,等於是新的金融槓桿工具。

    結論:從 OpenAI 與 Anthropic 同步動作可以確定,下一輪競爭不在模型排行榜,而在「誰掌握企業 AI 的部署層與顧問話語權」。


    二、部署層吃進來,誰被擠到邊緣?

    當模型公司變成「顧問+SI」,原本的價值鏈會發生三件殘酷的事:

    1. 雲服務商:從「平台」變成「賣算力」的上游供應商

    在這波布局裡,OpenAI/Anthropic 緊抱 Azure / Google Cloud,但他們不是幫雲賣方案,而是吸走應用層的策略主導權。

    • 雲廠仍然賺得到錢,但越來越像 「電力公司」:
    • Capex 繼續狂飆(TAI 報告提到大廠未來幾年資本支出接近 千億美元級別)。
    • 卻無法掌控企業的 AI 路線圖與數據策略,因為那些是掌握在部署公司手裡。
    • 這對雲端原本期待的「平台 lock-in」是反向的:
    • Lock-in 發生在模型與部署方法論上,而不是在雲平台 API 上。

    2. 系統整合商(SI):風險是被巨頭「外包化」

    對傳統 SI 來說,最糟糕的劇本是:

    • OpenAI/Anthropic 設計方案、掌握客戶關係與資料策略;
    • SI 只做:
    • 接舊系統
    • 寫 Glue code
    • 做客製化前端

    也就是說,SI 被變成部署巨頭的「勞務外包工程隊」:有 revenue,沒話語權;有工時,沒資產累積。

    更糟的是,部署公司會接觸大量真實場景,形成橫跨產業的「用例資料庫+最佳實踐模板」,下一個客戶就可以直接複用,進一步壓縮 SI 的方案設計價值。

    3. 傳統顧問公司:PowerPoint 壕溝正在被 AI 侵蝕

    McKinsey、BCG 等顧問過去最大的 moat 是:

    • 巨量案例與產業 know-how
    • 能幫 CEO 把變革寫成 PowerPoint 與路線圖

    但現在:

    • AI 可以自動生成決策報告與方案草稿;
    • 部署公司握有真實運行中的 AI 系統數據,可以給出「在 200 家類似公司裡,這樣調整流程平均能提升 18% 生產力」這種高可信度的量化建議。

    💡 關鍵: 當顧問報告可由 AI+跨客戶數據自動生成,傳統顧問公司的核心「案例與洞察壕溝」正在被系統性稀釋。

    當顧問的洞察不再是專屬資產,而是 AI+跨客戶數據庫的副產品,他們的 PowerPoint moat 正在被系統性稀釋。


    三、對企業端:短期好處,長期鎖死?

    從 CIO/CTO 角度看,這波「部署公司」有明顯的短期甜頭,也有被低估的長期風險。

    短期:風險轉移與導入效率暴增

    • 一站式整合:
    • 模型選型、架構設計、PoC、合規、變革管理,一個團隊搞定,比自己組織內部拉專案組要快得多。
    • 最佳實踐快取:
    • 部署公司帶著跨產業成功案例與模板,等於把別人踩過的坑全部 productize 成 SOP,企業可以跳過大量 trial-and-error。
    • 對董事會的說法好交代:
    • 「我們與 OpenAI / Anthropic 合作」本身就是一張政治保險單,萬一專案失敗,也可以說是「產業標準尚未成熟」。

    長期:技術路徑與核心能力被「外包」的風險

    1. 技術與數據路徑被鎖死
    2. 部署公司會自然偏好自家模型與雲合作夥伴,
    3. 企業在資料標註、流程重構、權限設計上,全部繞著某家模型 API 打造。
    4. 轉向開源或本地方案的成本會隨時間指數上升。

    5. AI 能力被外包,內部只剩「使用者」

    6. 若關鍵的 Prompt 設計、Agent 架構、評估基準、風險治理全交給外部,
    7. 公司內部將缺乏真正懂 AI 系統行為與 trade-off 的技術決策者,
    8. 最終變成:AI 是一個黑箱服務,組織只會「發需求」而不會「設計系統」。

    9. 議價權與數據主權弱化

    10. 當企業營運越來越依賴一組「外部 AI 工作流」,
    11. 模型供應商調價、變更政策、限制遷移時,
    12. 企業的可選項只剩「吞下去」或「砍掉重練」。

    💡 關鍵: 部署公司幫企業快轉 3 年,同時也可能把技術路徑和資料綁死 10 年,代價是長期議價權與技術主權。

    簡單說:部署公司幫你加速 3 年,也可能幫你鎖死 10 年。


    四、這是雲戰 2.0,還是壟斷前奏?

    Anthropic 對 Google Cloud 5 年 2000 億美元承諾、OpenAI 與 Azure 的深度綁定,加上大廠動輒 千億級 capex,共同構成了一個事實:

    算力戰已經進入「模型巨頭+雲巨頭」的聯盟戰,部署層是他們建立新壟斷的前線。

    這對 中端開發者、本地/開源方案 的擠壓會出現在三個層面:

    1. 心智空間被「標準方案」佔滿
    2. 當 OpenAI/Anthropic 的部署團隊變成「企業 AI 的預設選項」,
    3. 中小型開發公司變成「補洞」角色,只在標準方案以外的小角落接外包。

    4. 資源與資料紅利集中

    5. 部署公司看到跨產業的真實運行數據,
    6. 能比任何開源社群更快迭代出穩定可用的模板與工具,
    7. 長期形成資料與方法論的雙重 Compounding 優勢。

    8. 監管與合規成本成為護城河

    9. 未來若監管要求更嚴(模型審計、數據本地化、風險報告),
    10. 大型部署公司反而樂見其成:因為他們可以吸收這些成本,
    11. 開源與本地方案則被迫面對合規成本,進一步邊緣化。

    這更像是雲戰 2.0:第一輪比的是 IaaS/PaaS;第二輪比的是「誰把部署層與變革方法論變成標準件」。


    五、技術人與創業者:要避的坑與可守的位置

    如果你是產品/技術領導者或創業者,面對這波「部署公司化」,有三件事必須立刻做決策:

    1. 拒絕把核心能力完全交給外包
    2. 即使與 OpenAI/Anthropic 合作,也要在內部建立:
      • 模型評估與選型能力(能比較封閉模型與開源模型的 trade-off);
      • Prompt/Agent 設計與評測框架;
      • 資料治理與風險管理的自有準則。
    3. 把外部部署公司視為「加速器」,而不是「大腦」。

    4. 刻意設計「可替換性」與「多模型」的架構

    5. API 層一開始就做抽象,不讓任何單一模型供應商寫死你的業務邏輯;
    6. 核心業務流程盡量用可自託管的開源模型建立備援路徑;
    7. 把「切換供應商」視為必要工程,而不是罕見事件。

    8. 創業者的價值定位:避開「被巨頭吃掉的層」

    9. 不要去做「幫 OpenAI 寫客製化前端」這種註定被內建的工具;
    10. 尋找巨頭不願碰或碰不了的區域:
      • 高度垂直的行業流程與合規細節(醫療、政府、製造 OT 等);
      • 本地部署+極高隱私要求的場景;
      • 幫企業建立 「多模型治理與觀測層」 的工具與平台。

    最後的判斷是:企業 AI 的勝負不再看誰的模型跑分高,而是看誰控制「部署層+變革方法論」;但對技術人與創業者來說,真正能防守的價值,將來自你能否在巨頭主導的部署生態中,建立一個不依賴單一模型供應商、仍保有技術主權與議價權的位置。現在不做架構與策略上的防禦,兩三年後,你只剩簽約的份。


    🚀 你現在可以做的事

    • 盤點公司內部 AI 專案與供應商,畫出目前的「部署層+模型」依賴圖,標出潛在鎖死點
    • 設計一層抽象的 AI API 或「多模型路由層」,先在一個業務流程上實驗切換不同模型供應商
    • 若你是創業者,挑一個垂直行業(如醫療或製造),訪談 5 家企業,找出巨頭部署公司尚未解的高合規或本地化痛點,以此為題做 PoC
  • Symphony 與自管 Agent 的技術拆解

    Symphony 與自管 Agent 的技術拆解

    📌 本文重點

    • 讓 Agent 主動拉工單並自排程,減少工程師 babysit
    • 採用混合 Multi-Agent 模式與明確權限邊界
    • 透過 Task Queue + Worker + 審批閘門串起從工單到 PR 的全流程

    人類注意力已經成為工程團隊採用 AI 助手的主要瓶頸:Agent 能寫 code,但你要一直盯著它。Symphony 類的自管 Agent 系統,直接改變的是這件事:

    從「工程師 babysit 多個 Agent」→「Agent 自己從 Linear / Jira 拉工單、自排程、跑完整個 CI/CD pipeline,只在關鍵節點請你按一次 Approve」。

    下面從實作角度拆解:如何設計任務拉取、Multi-Agent workflow、與 CI/CD 權限邊界;最後給一個「自動修 bug → 開 PR → 回寫 Linear 狀態」樣板。


    重點說明

    1. 工單拉取與任務自排程

    核心是讓 Agent 變成一個長壽命 worker,定期從任務池拉工單,而不是被動等待 API 呼叫。

    工單來源:

    • Linear: /issues, /webhooks, /comments
    • Jira: /rest/api/3/search, /rest/api/3/webhook

    Polling vs Webhook:

    • Polling(簡單好 Debug)
    • 優點:
      • 實作簡單,只要定時 cron + API token
      • 不怕 webhook misconfig / 防火牆問題
    • 缺點:

      • 有延遲(30s–5min)
      • 需要自己做去重 / 任務狀態同步
    • Webhook(推薦長期方案)

    • 優點:
      • 事件即時觸發,適合高優先 bug / incident
      • 可根據事件類型直接分路由(bug vs feature)
    • 缺點:
      • 需要公開 endpoint + 驗簽
      • 部署與權限設定更複雜

    實務上常用 混合策略:

    • Webhook 處理新建 / 更新事件
    • Polling 每隔 5–10 分鐘做 reconcile,修正漏觸發 / 失敗同步

    💡 關鍵: 用「Webhook 即時 + 每 5–10 分鐘 Polling 校正」的混合策略,可以在保持即時性的同時降低漏事件風險。

    任務分派與併發控制:

    • 任務表核心欄位建議:
    • id, source(issue_id), priority, status(queued/running/failed/done), agent_type, lock_owner, lock_expires_at
    • 分派策略可以簡化成:
    • 優先級隊列:依 Linear priority / label 映射成數值
    • 技能匹配:根據 label → agent_type(例如 frontend, backend, infra)

    併發與重試控制的關鍵:樂觀鎖 + visibility timeout

    -- 簡化的任務鎖定 SQL
    UPDATE tasks
    SET status = 'running', lock_owner = :agent_id, lock_expires_at = NOW() + interval '15 minutes'
    WHERE id = (
      SELECT id FROM tasks
      WHERE status IN ('queued', 'failed')
        AND (lock_expires_at IS NULL OR lock_expires_at < NOW())
      ORDER BY priority DESC, created_at ASC
      LIMIT 1
      FOR UPDATE SKIP LOCKED
    )
    RETURNING *;
    

    好處:

    • 避免多個 Agent 搶同一張工單
    • Agent 崩潰 / timeout 時,lock 過期後可被其他 Agent 接手(類似 SQS visibility timeout)

    2. Multi-Agent:中心協調 vs 任務接力

    現代多 Agent 系統基本都落在兩種模式上(參考 Agents as Tools vs Handoffs)。

    模式 A:中心協調(Agents as Tools)

    • 一個「指揮官」Agent + 多個「工具」Agent
    • 主 Agent 保留全局 context 與決策權,子 Agent 像 function call

    • 示意(虛擬 code):

    const orchestrator = new OrchestratorAgent({
      tools: {
        codeAgent: callCodeAgent,
        testAgent: callTestAgent,
        infraAgent: callInfraAgent,
      }
    });
    
    await orchestrator.run({
      goal: "Fix bug #123 in service A and deploy to staging",
      constraints: { require_approval_for_deploy: true }
    });
    

    適合:

    • 需求不明確,需要動態拆解子任務
    • 需要統一治理(quota、安全策略、審計)

    模式 B:任務接力(Handoffs)

    • 任務隨流程在 Agent 之間流動
    • 每個 Agent 處理完就寫結果 + 下一步指派
    // task.payload 示例(存在 DB / Task Queue)
    {
      "status": "code_fixed",
      "next_agent": "test_agent",
      "artifacts": {
        "branch": "fix/BUG-123-null-pointer",
        "diff_summary": "..."
      }
    }
    

    適合:

    • Pipeline 已穩定(bugfix → test → PR → notify)
    • 易於水平擴展,每個 Agent 是一組 worker

    實務建議:多數專案採用 混合:

    • 一個 中心協調 Agent,但遇到標準化步驟(跑測試、開 PR、通知 Slack)時,交給 固定 handoff stage 的 worker;類似「主流程由 LLM 控制,heavy lifting 由 deterministic step 執行」。

    💡 關鍵: 把「決策」交給中心協調 Agent,把「重複且標準化的步驟」交給固定 worker,可以在保持靈活度的同時確保穩定性與成本可控。


    3. 與 CI/CD、code review、事故流程整合

    自管 Agent 的威力,取決於你如何設計 權限邊界 + 審批閘門。

    權限邊界設計:

    • Repo 層級:
    • 建立專用 GitHub App / GitLab Token,只開放:
      • repo:contents:write(但限制特定 org / repo)
      • pull_request:write
    • 禁止直接 push main / production branch
    • 環境層級:
    • Agent 只允許:
      • Deploy 到 staging / preview env
      • 觸發 read-only incident tooling(查 log、查 metrics),不要一開始就給 rollback / scale 權限

    審批閘門(approval gate):

    • 在 CI pipeline 加一個手動 stage,例如 GitHub Actions:
    jobs:
      tests:
        runs-on: ubuntu-latest
        steps:
          - uses: actions/checkout@v4
          - run: npm test
    
      deploy_staging:
        needs: tests
        if: github.actor == 'agent-bot'
        environment:
          name: staging
          # GitHub Environments 的 Reviewers 即是 approval gate
        steps:
          - run: ./deploy-staging.sh
    

    審計 log:

    • 每個關鍵行為都應落地:
    • 取得工單(issue_id, agent_id, reason, time)
    • 對 repo 的修改(branch, commit_sha, diff_summary, tests_run)
    • 任何 CI/CD trigger(workflow_id, inputs, result)

    • 建議統一經過一個 AuditService.log(event):

    await AuditService.log({
      actor: "agent-bot",
      action: "CREATE_PR",
      metadata: {
        issue_id: "ENG-1234",
        repo: "org/service-a",
        branch: "fix/ENG-1234-null-pointer",
        pr_url: "https://github.com/..."
      }
    });
    

    💡 關鍵: 把權限鎖在「staging + PR 層級」並配合審批閘門與審計 log,可以在不影響生產安全的前提下,讓 Agent 最大化自動化範圍。


    實作範例:從 Linear 抓 bug → 開分支 → 修 code → 開 PR → 回寫狀態

    以下是一個縮小版 blueprint,你可以直接改成自家 stack。

    1. 任務入口:Linear Webhook + 任務表

    Linear Webhook 指向你的 /linear/webhook:

    // Express 風格
    app.post('/linear/webhook', async (req, res) => {
      const event = req.body;
    
      if (event.type === 'IssueCreated' || event.type === 'IssueUpdated') {
        const issue = event.data;
    
        // 僅處理 bug + 特定 team
        if (issue.team.key === 'ENG' && issue.labelNames.includes('bug')) {
          await TaskRepo.enqueue({
            source: 'linear',
            source_issue_id: issue.id,
            priority: mapLinearPriority(issue.priority),
            agent_type: 'bugfix',
            status: 'queued'
          });
        }
      }
    
      res.sendStatus(200);
    });
    

    2. Bugfix Agent Worker(核心 loop)

    async function bugfixWorkerLoop() {
      while (true) {
        const task = await TaskRepo.acquireNext('bugfix', process.env.AGENT_ID);
        if (!task) {
          await sleep(5000);
          continue;
        }
    
        try {
          const issue = await LinearApi.getIssue(task.source_issue_id);
          const repo = mapIssueToRepo(issue);
          const branch = `fix/${issue.identifier}-${slug(issue.title)}`;
    
          await GitService.createBranch({ repo, from: 'main', branch });
    
          const diff = await CodeAgent.fixBug({
            repo,
            branch,
            issue_description: issue.title + '\n\n' + issue.description,
            files_hint: inferRelatedFiles(issue)
          });
    
          await GitService.commitAndPush({ repo, branch, message: `fix: ${issue.identifier}` });
    
          const pr = await GitService.createPR({
            repo,
            branch,
            base: 'main',
            title: `[Agent] Fix ${issue.identifier}: ${issue.title}`,
            body: renderPRBody(issue, diff)
          });
    
          await LinearApi.updateIssue(task.source_issue_id, {
            state: 'In Review',
            descriptionAppend: `\n\nLinked PR: ${pr.url}`
          });
    
          await TaskRepo.markDone(task.id);
        } catch (err) {
          await TaskRepo.markFailed(task.id, { error: String(err) });
        }
      }
    }
    

    關鍵點:

    • CodeAgent.fixBug 本身可以是一個 Symphony / Claude Managed Agent:
    • 有自己的工具:get_file, apply_diff, run_tests
    • 有自己的「Outcomes」條件(例如:測試必須綠燈、diff 不能超過 500 行)
    • Worker loop 要能容錯:task failure 不要直接 crash process

    3. 錯誤恢復與常見坑

    (1) stale context / 版本衝突

    • 現象:Agent 基於舊 commit 生成 patch,push 時發現 remote 已有新 commit
    • 對策:
    • 在 createBranch 前先 git fetch + 檢查 main 是否有新 commit
    • 若有衝突,改用 rebase + 再跑一次 CodeAgent,或直接加標籤請人工處理

    (2) 任務飢餓(某些工單一直排不到)

    • 常見原因:
    • 單純用 FIFO,長工時任務卡住隊列
    • 高 priority 任務一直插隊
    • 對策:
    • 採用 優先級 + aging:等待時間越久,自動提高 effective priority
    • 給長任務單獨的 queue 或 agent_type

    (3) 被動等待人工決策,Agent 資源被佔住

    • 例如:Agent 開 PR 後要等 Reviewer,期間 worker 就 idle with lock
    • 對策:
    • 把「等待人工」拆出成另一個狀態:
      • 任務設為 status = waiting_human
      • PR merge / Linear 狀態變更時再由 webhook 建下一個 task(例如 deploy)

    (4) AI 決策不穩(修了錯問題)

    • 這是現在 Agent 最大痛點之一(參考「AI is getting better at doing things, but still bad at deciding what to do」)。
    • 對策:
    • 對 CodeAgent 設定明確 Outcome 定義:
      • 測試要準備好一組 reproduction test
      • 用獨立 Evaluator Agent 根據 log / diff 給出 pass / needs-clarification
    • 讓 Agent 更常問問題:若重現步驟不完整,直接在 Linear 開 comment 要求補充,而不是盲修。

    建議與注意事項

    1. 從「觀察型 Agent」開始,不要一開始就給寫入權限

    2. 先只允許:讀工單 → 產生修復方案 / diff 草稿 → 貼回 Linear。穩定後再打開 PR 寫入、最後才接 CI/CD。

    3. 集中化審計與開關

    4. 所有 Agent 行為走一個 Agent Gateway / Orchestrator,集中:

      • 配額控制
      • 風險開關(feature flag 一鍵關掉所有 auto-deploy)
      • log / metrics / alert
    5. 明確定義「哪一段流程可以 0 人工」

    6. 常見安全配置:

      • bugfix PR 可以由 Agent 全自動產生,但 merge 必須人工
      • staging deploy 可自動,production deploy 必須經 Slack / PagerDuty approve
    7. 將 Agent 視為「非穩定服務」而非傳統微服務

    8. 接受它偶爾會做奇怪決策,因此整個系統必須:

      • 有清楚的 rollback 路徑
      • 任務永遠由 queue 控制,不綁死在單一 process
      • 重要資源(code、infra)永遠有 versioning + 審批

    如果你已經有 Linear / Jira + GitHub + CI/CD 的基本骨架,其實不用重建世界:

    只要加上一個 Task Queue + Agent Worker + 守門的 Orchestrator/Approval Gate,你就能讓 Symphony 類的自管 Agent 為團隊接手一條完整的「從工單到 PR」流水線,真正從盯著 Agent 寫 code,變成只盯少數關鍵決策點。

    🚀 你現在可以做的事

    • 在現有 Linear / Jira 加一個 Webhook,寫入自建的 tasks 資料表作為任務池
    • 實作一個最小版 bugfixWorkerLoop,先只產生修復方案與 diff 草稿貼回工單
    • 在 CI/CD 中加入只對 agent-bot 生效的 staging deploy job,並配置 GitHub Environments 審批閘門
  • 用 Deer-Flow 自建長跑 AI SuperAgent

    用 Deer-Flow 自建長跑 AI SuperAgent

    📌 本文重點

    • Deer-Flow 把長時間任務拆成可控模組
    • 透過記憶體與子代理協作支援長期、多階段任務
    • 搭配沙盒與工具調用,可快速做出實用自動化 Pipeline

    只要先把任務切成模組、再讓 Agent 自己排程與記憶,Deer-Flow 能幫你把「要跑幾小時」的專案變成一條可控又可復用的自動化流程。

    專案連結:bytedance/deer-flow


    核心功能:把「長時間任務」拆成可控模組

    這一節先講概念,但每個小節都會對應到你可以馬上去做的事。


    1. 任務調度:讓 Agent 分段跑,而不是一口氣硬撐

    Deer-Flow 的定位是「long-horizon SuperAgent harness」,核心就是任務調度(scheduler):

    • 把大任務拆成多個 stage(例如:資料收集 → 清洗 → 分析 → 報告)
    • 每個 stage 由一個或多個子代理(subagents)負責
    • 調度器會決定:
    • 什麼時候喚醒哪個子代理
    • 什麼時候暫停、重試、或改走另一條路徑

    你可以把它想像成「AI 版本的 Airflow + 任務導向的聊天界面」。

    💡 關鍵: 把長任務拆成多個 stage,讓 scheduler 分段調度 subagents,可以大幅降低單次失敗風險並提升整體可控性。

    你可以馬上做的事:

    1. 打開專案的 examples/ 資料夾,看官方提供的 flow 定義(多半是 YAML 或 Python pipeline)。
    2. 想一個你日常會重複做的 3–4 步驟任務(例如:抓資料 → 存 DB → 寫 summary),在筆記上先畫出 3–4 個方框,對應到未來的 stage 名稱。

    2. 記憶體管理:讓 Agent 記得「之前做過什麼」

    長時間任務的難點,不是算力,而是「上下文會爆掉」。

    Deer-Flow 幫你管的是:

    • 短期記憶(working memory):某個子任務當下需要的上下文
    • 長期記憶(long-term memory):歷史任務紀錄、重要結果、被標記的關鍵中間產物
    • 記憶裁剪:把不重要的對話 / log 丟掉,只保留後續階段會用到的東西

    這樣一來,你可以讓同一個 Agent:

    • 早上先跑一輪資料爬取
    • 下午再接續早上的結果繼續清洗與分析

    你可以馬上做的事:

    1. 在官方 demo 裡,找到記憶相關設定(通常會指定儲存路徑或使用向量資料庫)。
    2. 先用預設的本地檔案儲存方式,觀察它怎麼把多輪任務寫進 log / memory,了解自己之後可以在哪裡接入自己的資料庫。

    3. 子代理協作 + 工具調用:像組一隊虛擬實習生

    Deer-Flow 支援多個 subagents,每個都可以:

    • 使用不同的 LLM(例如:一個負責寫程式,一個負責資料分析)
    • 綁不同的工具(HTTP、資料庫、內部 API)
    • 透過 message gateway 互相傳遞任務與結果

    同時,它內建「工具調用」的框架:

    • LLM 輸出「要用哪個工具 + 參數」
    • Deer-Flow 幫你實際執行(例如發 HTTP 請求、查 DB)
    • 把結果再丟回 LLM 繼續推理

    你可以馬上做的事:

    1. 在 tools 或 skills 相關的範例中,找到 HTTP request 或資料庫工具的例子。
    2. 把它改成呼叫你公司內部一個可公開測試的 API(例如:/health、/status),確認整條「LLM 決定 → 工具執行 → LLM 使用結果」流程可用。

    4. 沙盒執行程式碼:讓 Agent 先在安全盒子裡試錯

    Deer-Flow 特別強調 sandboxes:

    • Agent 產生或修改程式碼時,不會直接在主機上執行
    • 而是丟到隔離環境(容器 / sandbox 子進程)裡跑
    • 出現錯誤時,log 會被收集回來給 LLM 參考,做下一輪修正

    這一點非常適合以下情境:

    • 讓 Agent 自動寫爬蟲、清洗腳本
    • 讓 Agent 幫你布署一個小型服務(只在 sandbox 測試通過後才進正式環境)

    你可以馬上做的事:

    1. 在官方 demo 裡跑一個「code sandbox」相關示例,看它怎麼把程式碼丟到沙盒執行。
    2. 把 sandbox 內部要執行的腳本換成你平常會用的簡單任務,例如:讀取一個 CSV,輸出 JSON。

    適合誰用:3 個具體場景


    場景 1:長時間資料爬取與整理

    典型流程:

    1. Agent A:負責定義爬取策略(網站列表、節奏控制)
    2. Agent B:實際發 HTTP 請求、解析 HTML / API
    3. Agent C:清洗資料、存進資料庫
    4. Agent D:最後產出摘要報告(例如每天一份 Markdown 摘要)

    Deer-Flow 的用法:

    • 每個 Agent 是一個 subagent
    • 任務調度器負責安排「今天要爬哪些」、「昨天失敗的要重試」
    • 記憶體管理幫你記住爬過哪些 URL,避免重複

    行動建議:

    • 選一個你每天都會看的公開資料來源(例如某政府開放資料 API),用 Deer-Flow 做一個「每日抓取 + insert DB + 產出報表」的 pipeline。

    場景 2:從需求到部署的自動化小專案

    你可以把它當成一個「AI junior developer」:

    1. Agent 讀取你的需求(功能描述、預期輸入輸出)
    2. 在 sandbox 裡生成與跑單元測試
    3. 修正錯誤
    4. 最後產出可部署的腳本或 Dockerfile

    搭配本地 LLM(例如 Qwen 3.6 27B,搭配 MTP 加速,參考:這篇 Reddit 分享),你可以完全在內網完成這一串。

    💡 關鍵: 搭配 Qwen 3.6 27B 與 MTP,有實務經驗分享可達到推理速度約「2.5×」提升,使本地端長任務也具備實用性。

    行動建議:

    • 挑一個小腳本需求,例如:
    • 定期掃描資料夾,壓縮過期檔案
    • 監控某個 API latency,超標就寄信
    • 讓 Deer-Flow 的 Agent 在 sandbox 中生成並測試這個腳本,再由你審核後部署。

    場景 3:定期報表生成(營運、行銷、IT 系統狀態)

    想像每週要手工做的:

    • 把資料庫中的數據抓出來
    • 做一些聚合 / 分析
    • 輸出 PowerPoint 或 Markdown 報告

    Deer-Flow 可以這樣組:

    1. 工具:資料庫查詢工具(連到你的 PostgreSQL / MySQL)
    2. Agent:
    3. 一個負責定義查詢與聚合邏輯
    4. 一個負責把結果轉成自然語言與圖表描述
    5. 調度:排成 cron-like 任務,每週執行一次

    行動建議:

    • 從一個最簡單的報表開始,例如「每週新用戶數」,用 Deer-Flow 將流程自動化,先做到:
    • Agent 查 DB → 產出一份 Markdown 報告存檔 → 你手動審閱

    怎麼開始:最小可行 Pipeline

    下面是一條「週末就能跑起來」的最簡路線。


    步驟 1:環境與安裝

    1. 準備一台有 Python 3.10+ 的機器(本機或雲端皆可)。
    2. 進入命令列:
    git clone https://github.com/bytedance/deer-flow.git
    cd deer-flow
    python -m venv .venv
    source .venv/bin/activate  # Windows 用 .venv\Scripts\activate
    pip install -r requirements.txt
    
    1. 確認可以跑官方 demo(通常在 examples/):
    python examples/basic_flow.py
    

    目標:先看到一個完整任務從「開始 → 調用 LLM → 調用工具 → 結束」的 log。


    步驟 2:接上一個開源 LLM(本機或雲端)

    你有兩條路:

    • 本機模型:用 llama.cpp 或 Ollama 跑 Qwen 3.6 之類的模型
    • 雲端 API:用 OpenAI、Anthropic 或其他 OpenAI-compatible 服務

    以 OpenAI 介面為例,Deer-Flow 通常會在設定檔或程式中要求:

    llm_config = {
        "endpoint": "https://your-openai-compatible-endpoint/v1",
        "api_key": "YOUR_KEY",
        "model": "qwen-3.6-32b-instruct"  # 或其他你有的模型名
    }
    

    行動建議:

    • 如果你已經有在用本地模型,直接把你熟悉的 OpenAI-compatible endpoint(例如 vLLM、自建 server)填進來,確認 Deer-Flow 可以正常發出 completion / chat 請求。

    步驟 3:串一個最簡單的工具(HTTP / 資料庫 / 內部 API)

    以 HTTP 工具為例,你可以新增一個 tool:

    from deer_flow.tools import register_tool
    import requests
    
    @register_tool("get_status")
    def get_status(url: str):
        resp = requests.get(url, timeout=10)
        return {"status_code": resp.status_code, "body": resp.text[:1000]}
    

    然後在 Agent 的工具清單中加入 get_status,讓 LLM 可以呼叫它:

    • Prompt 裡描述:「有一個工具 get_status(url) 用來檢查服務狀態」
    • 將你的內部 /health API 當成第一個測試目標

    行動建議:

    • 先讓 Agent 自己決定:
    • 什麼時候要呼叫 get_status
    • 呼叫後如何解讀結果(例如:狀態碼非 200 就記錄成 incident)

    週末練習腳本:從官方 demo 改成你的業務任務

    把以上步驟變成一個可執行的「週末計畫」:

    1. 跑起官方 demo
    2. 目標:看到完整的 log 與結果
    3. 換成你的 LLM
    4. 本地 Qwen / 雲端 API 任一種
    5. 串一個工具
    6. HTTP 或資料庫擇一
    7. 改寫 flow
    8. 讓 Agent 幫你跑一個真實業務任務,例如:
      • 每日抓一個內部 API 的統計數據
      • 存到一個簡單的 SQLite / CSV
      • 產出一行 summary

    做到這裡,你就已經擁有一個「專門幫你跑重複工作幾小時」的長跑 AI SuperAgent 雛型,接下來再慢慢加 stage、加子代理,就能讓它接手越來越多的例行任務。

    💡 關鍵: 先完成最小可行 pipeline,再逐步增加 stage 和工具,可以在風險可控下循序擴張自動化範圍。


    🚀 你現在可以做的事

    • 到 GitHub 下載並跑一次 bytedance/deer-flow 的官方 examples/basic_flow.py
    • 挑一個你日常 3–4 步驟的例行任務,畫出對應 stage,準備改寫成 Deer-Flow pipeline
    • 接上你的第一個實際工具(例如內部 /health API),驗證「LLM 決策 → 工具執行 → LLM 消化結果」這條鏈路在你環境中可用
  • Cloudflare AI 一鍵開站實戰指南

    Cloudflare AI 一鍵開站實戰指南

    📌 本文重點

    • Cloudflare + AI Agent 把建站流程變成一條指令
    • Agent 幫你自動處理帳號、網域、DNS 與部署
    • 透過細分工具與沙盒權限控制降低風險

    用一句話講清楚:這套 Cloudflare + AI Agent 的做法,就是讓「註冊帳號、買網域、設 DNS、部署前端/反向代理」整包變成一條指令搞定的自動流程。

    參考:Cloudflare 官方示範 AI Agent 如何創建帳號、購買網域並部署專案:https://blog.cloudflare.com/agents-stripe-projects/


    核心功能:AI 幫你做掉的「雲端雜事」

    把這個 Agent 想成會上 Cloudflare 幫你跑腿的「小助理」,它擅長三件事:


    1. 自動開帳號與綁付款

    能做什麼:

    • 依照你的輸入,幫你在 Cloudflare 建新帳號或登入既有帳號
    • 透過 API 綁定 Stripe 等付款方式(在 Cloudflare 文中是 demo Stripe)

    你可以立刻做的事:

    • 先準備一組「測試用帳號 + 測試信用卡」(例如:Stripe test mode)
    • 在 Agent 的設定檔裡,只給它測試環境的 API Key,避免直接動到正式金流

    2. 自動買網域 + DNS 設定

    能做什麼:

    • 搜尋可用網域,根據你描述的站點主題幫你推薦(如:blog、landing page)
    • 幫你在 Cloudflare Registrar 購買網域
    • 自動建立對應 DNS 記錄(A、CNAME、TXT 等)

    你可以立刻做的事:

    • 先選一個你願意「當實驗品」的便宜網域(.dev、.xyz)
    • 把「搜尋網域」「購買網域」拆成兩個獨立步驟,先讓 Agent 只做搜尋與列出候選,購買時再由你點選確認

    3. 一鍵部署 Pages / Workers / 反向代理

    能做什麼:

    • 建立 Cloudflare Pages 專案,從 GitHub/GitLab 拉前端程式碼並自動部署
    • 建立 Workers 當 API gateway 或反向代理,轉發到你的後端
    • 將網域 CNAME / A 設到對應的 Pages 或 Workers,整站自動串起來

    你可以立刻做的事:

    • 先準備一個最簡單的範例 repo:只有 index.html 的靜態站
    • 在 Agent 裡把「部署 Pages」設計成可重複執行的腳本,之後要開新站只換 repo URL 與網域即可

    適合誰用:幾個實際場景


    1. 產品團隊:十個 Landing Page 反覆 A/B test

    • 你只需要寫清楚:產品描述、目標市場、想測的方案數
    • Agent 幫你:
    • 從模板庫挑版型
    • 幫你生成靜態文案 + 分版本
    • 各建一個 Pages 專案 + 子網域(如 v1.、v2.、v3)

    2. 個人開發者:接案每次都要幫客戶開新站

    • 預先寫好「開新客戶站」腳本:
    • 建 Cloudflare 帳號 + Project
    • 關聯 Git repo
    • 設 DNS + SSL
    • 真正接案時,只要把客戶資訊填進表單,Agent 幫你跑完流程

    3. 小團隊 SRE / DevOps:想把「開新環境」變成自助服務

    • 把目前手動 run 的 Terraform / CLI 流程,包成幾個固定步驟
    • 用 Agent 把這些步驟串成「對話式自助開環境」,讓工程師只回答幾個問題就能有 dev / staging 站

    怎麼設計安全的 Agent 流程與權限

    這類 Agent 一旦拿到金流與 DNS 權限,風險就很實際,所以要先設計好「它能做什麼」與「什麼一定要人按確認」。

    💡 關鍵: 把高風險操作拆成小工具並加人類確認,是在維持自動化效率下控管金流與 DNS 風險的核心做法。


    步驟 1:把任務拆成幾個明確能力(tools)

    建議至少拆:

    1. search_domains:搜尋可用網域
    2. purchase_domain:購買指定網域
    3. create_cf_account:建立 Cloudflare 帳號
    4. deploy_pages_project:建立 + 部署 Pages
    5. create_worker_and_route:建立 Worker 並設定路由
    6. update_dns_record:新增 / 修改 DNS

    每個能力對應一個 API client 或 script,Agent 只能呼叫這些「包裝好」的函式,不直接拿到 raw API key。


    步驟 2:為每個能力標示「是否需要人類確認」

    一個簡單實作方式:在工具定義中加一個 flag:

    {
      "name": "purchase_domain",
      "human_approval_required": true,
      "max_amount": 20
    }
    

    然後在你的 Agent orchestrator 裡:

    • 若工具標示 human_approval_required,就把呼叫參數(例如網域名稱、價格)顯示在後台或發 Slack/Email
    • 只有當你點「批准」後,才真的讓後端執行這個工具

    步驟 3:使用「細分 API Key」與沙盒環境

    實務上避免「一把鑰匙開全公司」。

    • Cloudflare:
    • 建一個 專門給 Agent 用的 Account,只能管特定 zone
    • 使用 Scoped API Tokens,只開啟 DNS / Workers / Pages 所需權限
    • 金流(如 Stripe):
    • 一開始只給 test mode key
    • 等流程穩定後,再引入正式金流 + 嚴格人類審批

    實際腳本示範:從一句話需求到站點上線

    下面是一條「可複製」的流程。假設你在自建的 Agent 平台上,給模型這個任務:

    幫我開一個介紹 AI 工具評測的個人網站,用最便宜的可用網域,前端用現成靜態模板,掛在 Cloudflare Pages,上線後回報網址與部署細節。

    可以拆成以下幾步(你在 orchestrator 裡實作):


    1. 理解需求(LLM 自己完成)

    • 抽取:主題(AI 工具評測)、語言(繁中)、預算(便宜網域)、託管方式(Pages)

    2. 搜尋網域(需人確認)

    • Agent 呼叫 search_domains,傳入關鍵字:ai-tool-review, aitoolnotes 等
    • 回傳候選清單(名稱 + 價格)
    • 顯示在 UI 讓你勾選要買哪一個

    3. 購買網域(強制人類確認)

    • 你勾選後,才允許 Agent 呼叫 purchase_domain
    • 成功後記錄網域 ID,存入任務上下文

    4. 部署 Cloudflare Pages

    • 先由 Agent 幫你選模板+生成內容:
    • 基於 GitHub 上某個 starter template(設定在系統 prompt 裡)
    • 產生 index.html 內容(標題、關於我、最新評測文章列表 placeholder)
    • 呼叫 deploy_pages_project:
    • repo_url: 你預先準備好的 template repo
    • build_command: “npm run build” 或空字串(純靜態)
    • output_dir: dist / build

    5. 設定 DNS 與路由

    • Pages 部署完成後會有一個預設子網域
    • Agent 呼叫 update_dns_record:
    • 把剛買的網域的 @ 或 www CNAME 指到 Pages 網址

    6. 回報結果

    • Agent 最後整理:
    • 站點網址
    • 使用的網域價格
    • Pages 專案名稱與部署歷史連結
    • 你可以點進去檢查,如果沒問題,下次只要換一句需求就能複製整套流程

    想看 Cloudflare 官方更進階的案例(含 Stripe、Workers 整合),可參考:https://blog.cloudflare.com/agents-stripe-projects/


    實務風險與如何加上「人類確認」

    在 Reddit / Medium 上已經有很多討論,尤其是當 Agent 直接碰資料庫或金流時,風險會被放大。像 Vishesh Rawal 就分析了 AI Agent 連 PostgreSQL 時,因為連線被占住 6 秒而不是 5ms,讓連線池吞吐量掉了 1200 倍:https://medium.com/@visheshrawal/what-really-happens-inside-your-database-when-an-ai-agent-starts-querying-6d5254aeaa78

    💡 關鍵: AI Agent 對基礎設施與資料庫的「慢操作」,可能把吞吐量放大到原本的 1/1200,必須用節流與審批機制保護系統。

    對於 Cloudflare 這種「基礎設施類操作」,建議至少做三件事:


    1. 所有「花錢」的操作都要人工二次確認

    • 買網域、綁定正式金流、升級付費方案
    • 透過:Email、Slack bot、後台 Dashboard 的 Approve 按鈕

    2. 所有「改路由」的操作都要記錄審計

    • Log:誰下指令、Agent 呼叫了哪些工具、前後 DNS / Routing 差異
    • 發生事故時可以回溯,避免「Agent 胡亂改設定但找不到原因」

    3. 分環境:先在「沙盒帳號」驗證流程

    • 先在一個完全獨立的 Cloudflare 帳號跑完整流程
    • 確認行為符合預期後,才把相同腳本接到正式帳號,但權限再縮一級

    最低成本實驗指南:用現成工具在沙盒重現自動部署

    如果你想在一個週末內實際玩到這套「一鍵開站」流程,可以照這個極簡路線走:


    步驟 1:準備一個 Cloudflare 沙盒帳號

    1. 用新的 email 註冊一個 Cloudflare 帳號
    2. 建立一個 API Token:
    3. Template 選「Edit Cloudflare Workers」或「Edit Cloudflare Pages」
    4. Scope 只給某一兩個 zone(或一開始先不管 zone,只玩免費二級網域)

    步驟 2:選一個可以自訂 Tools 的 Agent 平台

    你可以用以下任一種方式:

    • 開源 / 自架:如基於 LangChain、LlamaIndex 或自寫 Python + OpenAI API
    • 商用平台:選一個支援「自訂工具 / Actions」的聊天式 Agent 介面

    關鍵是:你要能把「call Cloudflare API」包成一個工具,給模型呼叫。


    步驟 3:先做「最小可用流程」

    在沙盒帳號裡,先只讓 Agent 做兩件事:

    1. 建立一個 Cloudflare Pages 專案(用你現成的 GitHub 靜態站 repo)
    2. 回報部署網址給你

    這代表你只需要實作一個工具:deploy_pages_project,以及一個很簡單的 system prompt:

    你是一個幫助使用者在 Cloudflare Pages 部署靜態網站的助理。
    使用者只會提供 GitHub repo 連結與專案說明。
    你應該:
    1. 確認使用者需求
    2. 呼叫 deploy_pages_project 工具
    3. 回報部署後的網址與任何錯誤訊息。
    不要購買網域,只使用預設的 Cloudflare Pages 網址。
    

    等這條 pipeline 穩定後,再逐步加入:搜尋網域 → DNS 設定 → Workers 反向代理 → 網域購買(最後才加)。


    快速整理:這套做法的價值

    • 把「開新站」變成一條指令:從建帳號、買網域到部署,都由 Agent 操作 Cloudflare 完成
    • 可複製的腳本化流程:不同產品/客戶只改描述與 repo,其餘通用
    • 安全可控:透過細分工具、Scoped Token、人工審批,把風險鎖在沙盒與少數關鍵節點

    💡 關鍵: 先用 Pages 自動部署當起點,再逐步接入網域、Workers 與金流,是導入 Cloudflare Agent 化的漸進路線。

    如果你手上已經有穩定的 Git 部署流程,下一步就可以試著讓 Agent 幫你「接手 Cloudflare 那一段」,從最簡單的 Pages 自動部署開始,慢慢走向真正的一鍵開站。

    🚀 你現在可以做的事

    • 在 Cloudflare 開一個沙盒帳號並建立專用 Scoped API Token
    • 準備一個只含 index.html 的 GitHub 靜態站 repo,作為 Pages 測試專案
    • 在任一支援自訂 Tools 的 Agent 平台上實作 deploy_pages_project,跑通最小可用一鍵部署流程
  • Chrome 偷塞 4GB 模型,踩到瀏覽器戰爭的新雷區

    Chrome 偷塞 4GB 模型,踩到瀏覽器戰爭的新雷區

    📌 本文重點

    • Chrome 默默塞入 4GB 本地 AI 模型,瀏覽器正變成隱形 OS
    • 本地 AI 等於新一層追蹤與權限風險,缺乏透明度問題巨大
    • 監管將從「模型安全」走向「部署與預設值」治理,透明與可關閉成新護城河

    第一時間就先把立場講明白:Chrome 在未經明確告知與同意的情況下,默默塞進 4GB 本地 AI 模型,代表瀏覽器正式走向「隱形 OS」——也正式踩進用戶權益與監管紅線。 這不是單一產品決策,而是整個 AI 產業競賽邏輯,被擠壓到瀏覽器這個前線的結果。


    為什麼 Google 非得把 AI 塞進瀏覽器?

    先理解動機,才能理解這次為何如此「硬上」。

    1. 成本壓力逼出本地推論
      雲端推論一問一答都在燒錢。Google 要把 AI 整合進搜尋、Workspace、Chrome,如果全部丟雲端推,等於在自家核心業務上加了一層永久稅。把 約 4GB 的模型直接塞進 Chrome,就是把一部分推論成本,轉嫁到用戶 CPU、GPU 和 SSD 上——而且不必問你願不願意。

    💡 關鍵: 把約 4GB 模型塞進 Chrome,是把原本在雲端燒的 AI 成本,直接轉嫁到使用者的個人硬體與儲存空間上。

    1. 瀏覽器是唯一全平台「強入口」
      終端 OS 被 Apple、Microsoft 卡死,行動端還要面對 App Store gatekeeping。瀏覽器是 Google 唯一能在 Windows、macOS、Android、甚至 iOS 上,直接「下放能力」到終端的通道。要把 AI 變成「基本設施」,Chrome 就一定會被當成系統級 runtime 來用。

    2. 和 OpenAI/Anthropic/Apple 的賽局
      今天 OpenAI 可以透過桌面 App、API 變成開發者的默認 AI runtime;Apple 則在 WWDC 把「Apple Intelligence」綁死在裝置與 OS 層。Google 若不在瀏覽器層直接「預裝 AI」,就等於把入口讓給別人。這是一場誰先占領「用戶默認環境」的戰爭,而 Chrome 是 Google 手上最後一塊最大棋盤。

    所以,從商業與技術角度看,Google 做「本地模型深度嵌入 Chrome」幾乎是必然。但這不代表它可以默默下載 4GB 模型,還假裝這只是例行更新。


    瀏覽器變「隱形 OS」:AI bloatware 與追蹤地獄的起點

    這次爭議最糟糕的地方,不是「模型有多大」,而是它被當成一個不用解釋、不用選擇的系統組件。這宣告了瀏覽器的新角色:

    瀏覽器不再只是裝網頁的容器,而是 AI 的隱形作業系統。

    問題是,OS 級元件如果沒有 OS 級透明度與控制權,後果會非常醜。

    從「外掛」變「預載」:bloatware 的歷史重演

    PC 時代,我們痛恨電腦一開機就塞滿預載軟體:吃資源、難移除、還常常在背後傳資料。今天 Chrome 偷塞 4GB 模型,本質是一樣的邏輯,只是換了 AI 皮。

    差別在於:

    • 模型可以持續更新變大,不是一次性安裝
    • 模型推論過程本身可能 生成、蒐集高敏感度語境資料
    • 模型輸出的行為,又會反過來影響你在網頁上的決策與行為

    如果瀏覽器變成「不可關的 AI 後台」,那不是功能加值,而是結構性風險。

    過去十年我們在跟 Cookie、第三方追蹤碼、指紋辨識打游擊戰。現在,瀏覽器內建模型等於多了一層「在你畫面上思考的程式」,它可以:

    • 看你打的每一行字(輸入法式的監聽問題再現)
    • 理解你看的每一個頁面內容(語意層追蹤)
    • 根據這些語境優化建議、搜索、甚至廣告

    如果這一切都是在「你以為只是打開一個瀏覽器」的前提下默默進行,那跟我們過去批評的黑箱推薦演算法、暗黑模式,完全是同一脈絡,只是換了一個更聰明也更難看懂的殼。

    💡 關鍵: 內建 AI 模型讓瀏覽器可以理解「你在看什麼、打什麼」,從追蹤點擊與 Cookie,升級到直接監聽完整語境。

    AI 模型進政府預審,瀏覽器卻免「知情同意」?

    有趣的對比是:Google、Microsoft、xAI、OpenAI、Anthropic 這些公司,已經和美國商務部旗下 CAISI(Center for AI Standards and Innovation) 合作,允許政府在模型公開前做前置審查與國家安全測試,甚至提供降低安全柵欄的版本來驗證風險。

    同一批公司在國安層面願意接受預審,卻在消費者端直接把 4GB 模型塞進百萬台終端,連一個清楚的彈窗選項都沒有。

    這對監管者來說,是非常明顯的訊號:業者知道 AI 有風險,知道要在高風險情境前置審查,卻在最貼近用戶生活的環境選擇「先上車再說」。 這就是未來被立法「修理」的最佳素材。


    Siri 誇大被罰、AI 模型預審上路:監管已在給市場畫線

    Chrome 塞模型這件事,若放在近期幾個案例旁邊看,脈絡會更清楚。

    Apple 因 Siri 誇大 AI 功能被求償 2.5 億美元

    Apple 因為在 Siri 的 AI 功能上過度行銷、實際落地嚴重延遲,最後選擇以 2.5 億美元和解。這案子傳遞的訊號是:

    • AI 功能不是「講爽的」,功能成熟度與溝通內容不匹配,會直接變成法律與金錢風險
    • 用戶對 AI 的期待,一旦被引導到某個高度,就會被法院視為「合理期待」

    Apple 是因為「說太多」被罰,而 Google Chrome 這次是「說太少」——甚至不說。兩者看似相反,實際上在監管者眼中是一體兩面:都在處理 AI 部署的誠實與透明問題。

    💡 關鍵: Siri 被罰 2.5 億美元,顯示「AI 能力講過頭」要付現金代價;Chrome 這種「不講清楚就部署」同樣是另一種高風險不誠實。

    模型國安預審:AI 變成「類核技術」級別基礎設施

    美國政府透過 CAISI,已經拿到 Anthropic、OpenAI、Google DeepMind、Microsoft、xAI 等公司最新模型的「預發布存取權」,用於國家安全測試。 White House 甚至討論要導入更廣泛的模型上線前政府審查流程。

    這種做法本質上是在宣告:

    • 大型 AI 模型不再被視為一般軟體,而是類戰略物資
    • 高風險能力必須在部署前,對「可能傷到誰」做出交代

    如果模型都要在國家安全層面預審,那麼當模型被默默部署到十億用戶的瀏覽器裡,卻沒有清楚的知情同意與關閉機制,監管者遲早會追問:為何在國家安全面前可以謹慎,在消費者權益面前卻可以粗暴?

    監管下一步:從模型審查走向「部署治理」

    目前的政策焦點還在「模型本身危不危險」。但這次 Chrome 事件會加速一個轉向:監管會開始管「模型怎麼被塞進用戶環境」。可能的方向包括:

    • 要求本地 AI 組件層級的顯示與管理界面(就像系統權限頁面)
    • 強制標示模型大小、資源占用、資料流向
    • 禁止在預設開啟狀態下收集特定敏感資料,除非有明確 opt-in

    一句話:模型審查只是上半場,下半場是部署與默認值的治理。


    開發者與企業:別再迷信「預設開啟」,透明+可關閉才是新護城河

    這件事對開發者與企業的真正啟示是:「預設開啟的 AI 能力」在監管與市場上都會越來越貴。 具體可以歸納成三點行動建議:

    把「AI 開關」當成一級產品需求,而不是設定頁腳的一行字

    • 任何會在本地常駐、持續監聽(鍵盤、麥克風、螢幕內容)或會吞大量資源的 AI 功能,一律需要顯性開關與清楚說明。
    • 不要只給「關閉推薦」這種模糊選項,而是拆成:
    • 是否下載/保留本地模型
    • 是否允許背景啟動
    • 是否允許上傳使用記錄作為訓練資料

    設計「最小可用 AI」而非「最大可見 AI」

    • 少用「一刀切全局代理」,多用場景式、任務式 AI 功能(例如:只在你按下 summarise 時才啟動模型)。
    • 本地模型可以是選配,而非隱形預載:先提供雲端模式+明確提示本地模式優劣,讓用戶自行選擇是否下載那 4GB。

    把「透明+可關閉」變成品牌資產,而不是合規負擔

    • 未來監管與集體訴訟只會比 Siri 那案更兇。誰先把 AI 部署的透明度、可關閉、可刪除資料流程做清楚,誰才有資格談「信任護城河」。
    • 對開發者而言,這不只是風險控管,也是差異化機會:敢在設定頁清楚寫出模型版本、大小、更新頻率、資料走向的產品,在一片黑箱裡會顯得非常不一樣。

    對使用者來說,短期內也只有一個務實建議:

    • 能選擇瀏覽器就別只用一個,把 AI 嵌入策略最「誠實」、開關最清楚的那個,當你的主力工具。 用行為投票,比在社群上抱怨更有效。

    Chrome 偷塞 4GB AI 模型,真正畫出的底線是:AI 不再是雲端玩具,而是本地基礎設施;但誰把它當黑箱塞進來,誰就會在下一輪監管與市場修正裡付出代價。


    🚀 你現在可以做的事

    • 打開你常用瀏覽器的設定頁,檢查是否有本地 AI、隱私與資料上傳相關選項,逐一確認與關閉不必要功能
    • 嘗試安裝第二個瀏覽器,實際比較各家對 AI 功能的說明透明度與開關粒度,再決定主力工具
    • 若你是開發者或產品負責人,列出產品中所有「預設開啟」的 AI 功能,為每一項設計清楚的說明文案與顯性開關頁面
  • 用 Gemini Webhooks 正確打開長任務 LLM

    用 Gemini Webhooks 正確打開長任務 LLM

    📌 本文重點

    • 用 Webhook 取代 polling,解決長任務阻塞
    • Webhook handler 要做到驗簽、冪等、極瘦
    • 任務抽象成 job+事件+worker,易於擴充與控管

    長任務 LLM(大檔案 RAG 摘要、批量程式碼分析、批次生成報表)現在普遍體驗很爛,核心原因通常只有兩個字:阻塞。

    傳統做法是:前端打一個同步 API,後端卡在那裡等 LLM 完成,或者先回 job_id,然後一直 polling 查狀態。前者直接拖垮後端連線與 gateway timeout,後者則是浪費資源+狀態更新延遲。Gemini Webhooks 正在解這個痛:把長任務變成事件驅動的推送流程,讓你的系統只在「有事發生」時醒來,而不是每 5 秒在那邊瞎問「好了沒?」。


    重點說明:為什麼要用 Gemini Webhooks

    💡 關鍵: 用事件驅動模式取代頻繁 polling,可同時避免 gateway timeout 和後端資源被無意義查詢拖垮

    1. 事件驅動:用任務狀態變更取代 polling

    在 Gemini API 中,長任務(例如 videos:asyncGenerate、大型批次推理)完成時,會透過 Webhooks 主動打到你註冊的 URL。概念上會有類似以下事件:

    • job.created:任務建立成功
    • job.running:模型開始處理
    • job.succeeded:任務完成,可讀取結果
    • job.failed:任務失敗,附錯誤碼

    你不再需要 setInterval 去拉 GET /jobs/{id},而是:

    1. 後端呼叫 Gemini 創建 job,拿到 job_id
    2. 立刻回傳給前端
    3. 等 Gemini 的 Webhook 打回來時,再更新 DB / 推訊息給前端

    這跟 Stripe、GitHub 的 Webhook 類似,但 LLM 任務的執行時間級距更大(秒 → 分鐘),而且往往輸出結果非常大,所以事件節點設計與重試策略尤其關鍵。

    💡 關鍵: LLM 任務可從「秒級」到「分鐘級」,用 Webhook 讓前端先回應、結果再補推,是改善體驗與穩定性的關鍵設計

    2. 可靠傳遞:重試機制與簽名驗證

    Gemini Webhooks 一般會具備:

    • 重試機制:如果你的 Webhook handler 回傳非 2xx,Google 會在一段時間內重試。你必須設計 handler 為冪等:同一個 event_id 打多次也不會重複處理。
    • 簽名驗證:Header 中會帶類似 X-Goog-Signature 的簽名,內容由 timestamp + body 使用 Google 公鑰/金鑰驗證。你必須:
    • 驗證 timestamp(避免重放攻擊)
    • 使用官方提供的 public key / JWKS 驗簽

    與 Stripe/GitHub 的差異在於:事件 payload 裡通常會內嵌部分結果或結果位置(例如 GCS 路徑、job result id),你要能快速把這些資訊導到後續 pipeline(儲存、後處理、通知)。

    3. 典型架構:前端提交通用長任務 + Webhook 回寫結果

    一個實際可落地的架構可以長這樣:

    1. 前端:
    2. 呼叫你的後端 POST /tasks,附上:

      • 檔案位置(GCS / S3 URL)或上傳檔案 ID
      • 任務類型(例如 rag_summary、code_batch_review)
    3. 後端 API(同步路徑):

    4. 在 DB 建一筆 tasks 紀錄(狀態 pending)
    5. 呼叫 Gemini Async API(例如:POST /v1/videos:asyncGenerate)並設定 webhook_config
    6. 把 job_id 寫回 DB,回應前端:

      json
      { "task_id": "t_123", "job_id": "g_job_abc", "status": "pending" }

    7. Gemini Webhook → 你的 Webhook handler:

    8. 收到 job.succeeded 或 job.failed 事件
    9. 驗簽、判斷是否已處理
    10. 更新 DB 的 tasks.status,並把結果丟進 message queue(例如 Pub/Sub / Kafka / SQS)

    11. 背景 worker:

    12. 從 queue 拉到「任務完成」事件
    13. 下載/讀取 LLM 結果,做後處理(切 chunk、寫向量 DB、生成報表 PDF 等)
    14. 通知前端(WebSocket / SSE / push)

    重點是:Webhook handler 要極瘦,只負責驗證 + enqueue,不做 heavy work,避免阻塞導致重試暴增。


    實作範例:簽名驗證、冪等與背景 worker

    以下用 Node.js / Go / Python 各給一個實作骨架,重點在「怎麼安全又穩定地吃 Webhook」。

    Node.js(Express)示意

    import express from 'express';
    import crypto from 'crypto';
    
    const app = express();
    app.use(express.raw({ type: 'application/json' })); // 保留原始 body
    
    function verifyGoogleSignature(req) {
      const signature = req.header('X-Goog-Signature');
      const timestamp = req.header('X-Goog-Timestamp');
      const body = req.body; // Buffer
    
      if (!signature || !timestamp) return false;
    
      const now = Math.floor(Date.now() / 1000);
      if (Math.abs(now - Number(timestamp)) > 300) return false; // 5 分鐘窗口
    
      const expected = crypto
        .createHmac('sha256', process.env.GOOGLE_WEBHOOK_SECRET)
        .update(timestamp + '.' + body.toString('utf8'))
        .digest('base64');
    
      return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected));
    }
    
    app.post('/webhooks/gemini', async (req, res) => {
      if (!verifyGoogleSignature(req)) {
        return res.status(400).send('invalid signature');
      }
    
      const event = JSON.parse(req.body.toString('utf8'));
      const { id: eventId, type, data } = event;
    
      // 冪等:如果 eventId 已處理過,直接回 200
      const exists = await hasEventProcessed(eventId);
      if (exists) return res.status(200).send('ok');
    
      await markEventProcessed(eventId);
    
      // 僅 enqueue,不做 heavy work
      await enqueueToQueue({ type, data });
    
      res.status(200).send('ok');
    });
    
    app.listen(3000);
    

    關鍵:

    • express.raw 保留原始 body,驗簽才不會失真
    • 使用 timingSafeEqual 避免時間側信道
    • hasEventProcessed / markEventProcessed 通常用 DB / Redis 實作 event_id 去重

    Go(net/http)示意

    func verifyGoogleSignature(r *http.Request, body []byte) bool {
      sig := r.Header.Get("X-Goog-Signature")
      ts := r.Header.Get("X-Goog-Timestamp")
      if sig == "" || ts == "" {
        return false
      }
    
      // 5 分鐘窗口
      tsInt, _ := strconv.ParseInt(ts, 10, 64)
      if math.Abs(float64(time.Now().Unix()-tsInt)) > 300 {
        return false
      }
    
      mac := hmac.New(sha256.New, []byte(os.Getenv("GOOGLE_WEBHOOK_SECRET")))
      mac.Write([]byte(ts + "." + string(body)))
      expected := base64.StdEncoding.EncodeToString(mac.Sum(nil))
    
      return hmac.Equal([]byte(sig), []byte(expected))
    }
    
    func geminiWebhookHandler(w http.ResponseWriter, r *http.Request) {
      body, _ := io.ReadAll(r.Body)
      defer r.Body.Close()
    
      if !verifyGoogleSignature(r, body) {
        w.WriteHeader(http.StatusBadRequest)
        return
      }
    
      var event GeminiEvent
      if err := json.Unmarshal(body, &event); err != nil {
        w.WriteHeader(http.StatusBadRequest)
        return
      }
    
      if alreadyProcessed(event.ID) {
        w.WriteHeader(http.StatusOK)
        return
      }
      markProcessed(event.ID)
      enqueue(event)
    
      w.WriteHeader(http.StatusOK)
    }
    

    Python(FastAPI)示意

    from fastapi import FastAPI, Request, Header, HTTPException
    import hmac, hashlib, base64, time, json
    
    app = FastAPI()
    
    SECRET = b"your-google-webhook-secret"
    
    def verify_signature(sig: str, ts: str, body: bytes) -> bool:
      if not sig or not ts:
        return False
      now = int(time.time())
      if abs(now - int(ts)) > 300:
        return False
      mac = hmac.new(SECRET, f"{ts}.".encode() + body, hashlib.sha256)
      expected = base64.b64encode(mac.digest()).decode()
      return hmac.compare_digest(sig, expected)
    
    @app.post("/webhooks/gemini")
    async def gemini_webhook(request: Request,
                             x_goog_signature: str = Header(None),
                             x_goog_timestamp: str = Header(None)):
      body = await request.body()
      if not verify_signature(x_goog_signature, x_goog_timestamp, body):
        raise HTTPException(status_code=400, detail="invalid signature")
    
      event = json.loads(body)
      event_id = event["id"]
    
      if await is_processed(event_id):
        return {"status": "ok"}
    
      await mark_processed(event_id)
      await enqueue_event(event)
      return {"status": "ok"}
    

    這三個例子都符合同樣原則:Webhook handler = 驗簽 + 去重 + enqueue,真正重的事丟給 worker。


    建議與注意事項:把坑踩在實驗環境就好

    1. 超時與錯誤恢復策略

    • Webhook handler 的處理時間要控制在幾百毫秒內,超時會觸發 Google 重試。
    • 重試代表同一事件可能會打多次,你必須:
    • 用 event_id + 唯一索引,確保不會重複更新任務
    • 在 worker 中也做去重(例如用 task 的狀態機 pending → processing → done)

    2. 任務去重與「鬼任務」

    典型問題:

    • 前端連點送出,後端重複創建 job → 成本爆炸
    • Webhook 僅回傳 job 狀態,但你找不到對應的 tenant / 任務

    建議:

    • 在 DB 給 client_request_id 加 unique constraint,後端收到同一個 client_request_id 時直接回已存在的 task_id / job_id
    • 把 tenant_id、user_id、trace_id 放進你自己的 tasks table,收到 Webhook 時用 job_id join 回 tasks 而不是在 payload 裡亂猜

    3. 安全:防止偽造 Webhook 與濫用

    • 一律使用 簽名驗證,不要只靠 IP 白名單
    • 驗證 timestamp,避免攻擊者重放舊事件
    • Webhook URL 單獨使用 domain / path,不與前台共用,方便 WAF 規則收斂
    • 若採多租戶 SaaS:
    • tasks 表一定要有 tenant_id,所有查詢都要帶 tenant scope
    • 配額計算(token、任務次數、併發 job 數)也要按 tenant_id 統計
    • 錯誤事件(job.failed)要能映射回 tenant,避免 debug 時完全看不懂是誰的錯

    4. 與現有框架整合:RAG、工作流、Serverless

    • 自建 RAG pipeline:
    • 把「文件上傳 → 向量化 → 寫入 vector DB」拆成多個任務
    • Gemini Webhook 只負責第一段(例如大檔整理+摘要),之後再觸發你既有的向量化 pipeline

    • 工作流引擎(Airflow、Temporal、Prefect):

    • Webhook handler enqueue 到 workflow engine queue
    • 在 workflow 裡設一個「等待 LLM 任務完成」的 node,node 的觸發由 Webhook 完成,而不是 cron / polling

    • Serverless(Cloud Run / Cloud Functions / Lambda):

    • Webhook handler 非常適合跑在 Serverless 上,因為多數時間是 idle
    • heavy worker 則可以獨立部署在 long-running service(K8s)或另一個 queue consumer 上

    結論:

    如果你的 LLM 產品裡已經出現「API 會卡 1 分鐘」「前端一直轉圈」「後端一堆 polling job 消耗資源」這些症狀,Gemini Webhooks 是目前最合理的重構切入點。把長任務抽象成 job + 事件 + worker 三件事,你可以:

    • 提升使用者體驗(提交即回應、狀態即時更新)
    • 降低後端長連線壓力與無意義 polling 成本
    • 更容易在多租戶 SaaS 中做配額控制與隔離

    從先把 Webhook handler 寫瘦、寫穩開始,你的長任務 LLM 系統就會開始好用很多。

    🚀 你現在可以做的事

    • 在現有後端加一個 /webhooks/gemini endpoint,實作驗簽+冪等邏輯
    • 把目前同步長任務改成「建立 job → 透過 Webhook 回寫結果」的流程
    • 選一個 queue(例如 Pub/Sub、Kafka 或 SQS)接 Webhook 事件,啟動獨立背景 worker 處理重任務
  • 把縮小版網路塞進你筆電:LLMSearchIndex 實戰

    把縮小版網路塞進你筆電:LLMSearchIndex 實戰

    📌 本文重點

    • 2 億頁壓成約 2GB 的「縮小版網際網路」可離線搜尋
    • 純本地檢索搭配任意 LLM,輕鬆組出 RAG 流程
    • 特別適合高隱私、內網環境與成本敏感的 RAG 應用

    用一句話定位:LLMSearchIndex 就是把「壓縮過的縮小版網際網路」塞進你筆電,讓你在本機就能做全網級搜尋,再拿結果丟給任何 LLM 做 RAG,完全不用再付搜尋 API 費。

    原始專案介紹可看 Reddit:https://www.reddit.com/r/LocalLLaMA/comments/1t3hokh/llmsearchindex_an_open_source_local_web_search/


    核心功能:一台筆電裝下一個「可離線的 Google 替身」

    1. 2 億頁壓縮索引,約 2GB 就能跑

    LLMSearchIndex 預先把網頁爬好、清洗、壓縮成自訂索引格式,涵蓋 FineWeb、維基百科等資料,超過 2 億頁內容壓進約 2GB 檔案。

    💡 關鍵: 把原本動輒數 TB 的網頁內容壓成約 2GB,使全網級搜尋第一次可以在一般筆電本機完成。

    你可以做的事:

    • 把它想成「只存文字精華的迷你網際網路」
    • 在任何一台 8GB RAM 以上的筆電或桌機上運行,不用伺服器
    • 直接拿來當你自建 RAG 系統的「泛網背景知識來源」,不用自己寫爬蟲 + 建索引

    2. 純本地檢索,不靠外部搜尋 API

    LLMSearchIndex 是一個 Python 函式庫,檢索完全在本機完成:

    • 不依賴 Google、Brave、Bing API
    • 不需要額外布署 SearXNG 這種 meta search
    • 問題 → 本機索引 → 回傳相關片段(含來源網址)

    實際效果:只要你還在用本地 LLM(如 Ollama、llama.cpp)或雲端 LLM(OpenAI、Claude 等),檢索這一段可完全脫離網路與付費 API,對公司內網環境或隱私要求嚴格的團隊特別實用。

    💡 關鍵: 把「搜尋這一步」完全搬到本地,不只省掉搜尋 API 成本,也避免把查詢內容外送到第三方服務。

    3. Python API + 任意 LLM,快速組出 RAG 流程

    LLMSearchIndex 的設計就是為 RAG 用:

    • 輸入:自然語言 query
    • 輸出:N 個相關片段(帶文字與 URL),可直接拼進 LLM 的系統提示或 context
    • 不綁特定模型,你可以串:
    • 本地模型(Ollama、vLLM、Kobold、LM Studio…)
    • 雲端模型(OpenAI、Anthropic、Gemini、Groq…)

    典型 workflow:

    1. 使用者問問題
    2. 用 LLMSearchIndex 搜索全網索引,取前 5–10 個片段
    3. 把片段整理成「context」
    4. 丟給 LLM 生成回答

    這整套,你可以在一支 Python 檔內完成。


    適合誰用:三種典型場景

    1. 公司內部知識問答:先查內網,再查「縮小版全網」

    情境:你有一個內部知識庫(Notion、Confluence、PDF…),已經做了 RAG,但常遇到:

    • 文件沒寫清楚,需要補充產業背景
    • 客戶問題牽涉到外部規範、標準、技術細節

    做法:

    1. 先用公司內部向量庫檢索(例如 Chroma、Qdrant、Weaviate)
    2. 若分數不夠高或結果太少,再用 LLMSearchIndex 查一次「全網索引」
    3. 把「內網內容 + 全網片段」一起餵給 LLM

    好處:

    • 內網問題走本地知識(更準、更貼合公司語境)
    • 外部背景靠本地全網索引補足,不用再打搜尋 API

    2. 研究人員做主題深度檢索

    情境:你是研究員 / 資深工程師,常需要:

    • 快速掃描一個新主題的相關文章
    • 找技術名詞、標準、實作細節的來源

    做法:

    • 用 LLMSearchIndex 做多輪查詢,像這樣:
    • 「LLM 推理最佳化 quantization 技術」
    • 「vLLM streaming serving 實作」
    • 「RAG selective retrieval cost optimization」
    • 把回來的片段整理成資料集,再讓 LLM 幫你摘要、對比觀點、拉時間線

    你得到的是:一套可重複的「本機文獻預篩管線」,比手動 Google → 開一堆分頁 → Copy/Paste 省力很多,也更隱私。

    3. 離線 / 高隱私環境下的「像 Google 一樣」輔助搜尋

    情境:

    • 政府、醫療、金融等內網環境不允許對外連線
    • 你只被允許「把工具帶進來」,不能讓資料出去

    做法:

    • 先在可上網環境下載索引檔與程式碼
    • 帶進封閉網路內安裝
    • 之後所有搜尋與 RAG 都在本機完成

    搭配 Selective RAG(參考 Silicon Protocol 思路):

    • 只有在「本地內網文件」不足以回答時,才啟動 LLMSearchIndex 檢索
    • 把返回片段壓縮(摘要、抽 key points),控制 context 在 3–4 萬 token,以節省 LLM 成本

    💡 關鍵: 用 Selective RAG 控制 context 在 3–4 萬 token 內,可以在維持回答品質的同時大幅壓低 LLM 推理成本。

    參考文章:


    怎麼開始:從 pip 到最小可用 RAG 範例

    以下程式碼是假想 API 介面,目的是讓你知道「整體長什麼樣」,實作時請以實際專案 README 為主。

    步驟 1:安裝與下載索引

    # 1. 安裝套件
    pip install llmsearchindex
    
    # 2. 下載預先建好的 2GB 索引
    llmsearchindex download --dataset fineweb-wikipedia
    # 或依 README 指示,選擇其他索引來源
    

    行動重點:確保你有至少 5GB 以上的剩餘磁碟空間與穩定網路,這一步可能會跑一陣子,但只需做一次。

    步驟 2:在 Python 裡發一個最簡單的 query

    from llmsearchindex import LLMSearchIndex
    
    # 載入索引(第一次載入會較慢,之後可快取)
    index = LLMSearchIndex("./indexes/fineweb_wiki.idx")
    
    # 發出一個查詢
    results = index.search(
        query="什麼是 Selective RAG,怎麼降低 LLM context 成本?",
        top_k=5
    )
    
    for i, r in enumerate(results, 1):
        print(f"[{i}] score={r.score:.3f}\nURL={r.url}\nSnippet={r.text[:200]}...\n")
    

    行動重點:

    • 改成你的問題跑一次
    • 看回傳的文字和 URL,確認內容大致合理

    步驟 3:把檢索結果接到任意 LLM(本地或雲端)

    以下以 OpenAI API 為例,你可以換成任何 LLM SDK:

    import os
    from openai import OpenAI
    from llmsearchindex import LLMSearchIndex
    
    client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
    index = LLMSearchIndex("./indexes/fineweb_wiki.idx")
    
    question = "請用中文說明 Agentic RAG 與傳統 RAG 的差異,並舉一個應用例子。"
    
    # 1) 先檢索
    hits = index.search(question, top_k=5)
    
    context_blocks = []
    for h in hits:
        context_blocks.append(f"來源:{h.url}\n內容:{h.text}")
    
    context = "\n\n".join(context_blocks)
    
    # 2) 再把 context 丟給 LLM
    prompt = f"""你是一位技術寫作者。
    根據以下資料回答使用者問題,回答要有條列與具體例子。
    
    【檢索到的資料】
    {context}
    
    【使用者問題】
    {question}
    """
    
    resp = client.chat.completions.create(
        model="gpt-4.1-mini",
        messages=[{"role": "user", "content": prompt}]
    )
    
    print(resp.choices[0].message.content)
    

    行動重點:

    • 把 model 改成你實際在用的模型
    • 若是本地模型(例如 Ollama),只需把「呼叫 OpenAI」那段換成對本地 API 的 HTTP POST

    步驟 4:加一點「Selective / Agentic RAG」邏輯

    目標:控制什麼時候查本機內網知識、什麼時候查全網索引,並讓 LLM 自己做選擇。

    下面是一個可直接複製的「最小工作流」範例(假設你已有 search_internal() 可查公司文件):

    def answer_question(question: str):
        """最小 Agentic + Selective RAG 工作流示意"""
        # 1) 先查內部知識庫
        internal_docs = search_internal(question, top_k=5)
    
        # 2) 請 LLM 判斷要不要額外查全網
        judge_prompt = f"""你是一個檢索決策助手。
        使用者問題:{question}
        下面是內部文件的部份內容,如果已足夠回答,就回答 NO;
        如果明顯需要外部背景知識,回答 YES。
    
        內部文件摘要:
        {internal_docs[:4000]}
    
        只回答 YES 或 NO。"""
    
        judge = client.chat.completions.create(
            model="gpt-4.1-mini",
            messages=[{"role": "user", "content": judge_prompt}],
            max_tokens=2
        ).choices[0].message.content.strip()
    
        web_context = ""
        if judge == "YES":
            web_hits = index.search(question, top_k=5)
            web_context = "\n\n".join(h.text for h in web_hits)
    
        # 3) 最終回答,Selective RAG:只注入必要的 context
        final_prompt = f"""根據以下資料,用清楚的條列方式回答問題。
    
        【內部文件】
        {internal_docs}
    
        【外部網路資料】
        {web_context}
    
        問題:{question}
        """
    
        ans = client.chat.completions.create(
            model="gpt-4.1-mini",
            messages=[{"role": "user", "content": final_prompt}]
        )
        return ans.choices[0].message.content
    

    這段做了幾件關鍵事:

    • 先用內部文件回答,避免 context 過大
    • 只在 LLM 判斷「需要外部背景」時才查 LLMSearchIndex → Selective RAG
    • 讓「要不要查外網」變成 LLM 可控制的動作 → Agentic RAG 思路

    你可以把這段包成 API,直接給前端 chat UI 使用,實際上就完成了一個「有公司腦、有縮小版全網腦」的混合助理。


    小結:什麼時候值得把 LLMSearchIndex 裝進你電腦?

    如果你符合以下任一條件,很值得試:

    • 不想再為 Brave / Bing / 其他 Web Search API 付費
    • 公司內網不能直連外網,但又需要一般網路知識
    • 已經有 RAG,但缺一層泛網背景,常被卡在「文件沒寫但網路上早就有答案」

    先從:

    1. pip install + 下載索引
    2. 跑一次簡單 query
    3. 用上面最小工作流範例接到你的 LLM

    開始把「縮小版網際網路」塞進你的 RAG pipeline 裡,用一台筆電就做出接近全網搜尋體驗的助理。

    🚀 你現在可以做的事

    • 打開 README,實際執行 pip install llmsearchindex 並下載一個索引檔
    • 改寫文中的 Python 範例,把 query 換成你真實工作會問的問題跑一次
    • 把「步驟 4」的 answer_question() 包成一個簡單 API,接到現有的內網 chat UI 做小規模試用
  • Claude Code:把你的一人開發組變成小團隊

    Claude Code:把你的一人開發組變成小團隊

    📌 本文重點

    • Claude Code 扛「從 issue 到 PR」整條開發流程
    • 百萬 token 上下文,能做跨檔案大規模重構
    • 與 issue 管理工具整合,連動任務與代碼
    • 把它當工作流 Agent,而不是單純寫程式助手

    Claude Code 要解決的問題很單純:不要只幫你「寫幾行程式」,而是幫你「從 issue 到 PR 到 release note」整條開發流程一起扛掉。

    Claude Code 官方頁面|參考閱讀:Claude Code Isn’t a Coding Tool. It’s Your Team’s New Workflow Engine.


    核心功能:不只是會寫程式的 Chatbot

    1. 百萬上下文 + 跨檔案重構

    Claude Code 的關鍵不是「會寫程式」,而是一次看得懂整個專案:

    💡 關鍵: 百萬 token 上下文讓 Claude Code 能一次理解整個大型 repo,支援跨模組重構與設計級別調整。

    • 支援百萬 token 上下文,實務上可以:
    • 一次讀完整個 monorepo 的關鍵目錄
    • 同時理解前後端、infra、文件
    • 實際能做的事:
    • 統一命名規則、API 介面:
      • 指令範例:

        「請在整個 apps/web 和 packages/api 裡,把 user profile 統一改成 UserProfile 類型,並更新相關型別定義與呼叫點。」

    • 大規模重構:改 routing、auth、logging 邏輯,而不是只改單一檔案

    行動建議:
    – 第一次用時,直接把「專案關鍵資料夾」拖進 Claude Code,請它輸出:
    – 架構圖
    – 主要模組關聯
    – 技術債/風險清單

    2. 代碼審查 + 任務追蹤

    Claude Code 把「code reviewer + 小 PM」包在一起用:

    • 代碼審查:
    • 貼 PR diff 或讓它自己產生 patch,請它從幾個角度審查:
      • 可讀性
      • 安全性
      • 可測試性
    • 指令範例:
      > 「這個 PR 幫我做 code review,重點看:1) SQL 注入風險 2) log 裡有沒有可能洩漏個資。」
    • 任務追蹤:
    • 你丟一串 TODO、散落在註解、issue 裡,它可以:
      • 幫你整理成任務列表
      • 按複雜度排序
      • 標註依賴關係

    行動建議:
    – 把你專案裡的 // TODO 集中給 Claude Code,看它幫你:
    – 分成「1 小時內可完成」「需要討論設計」兩類
    – 生成對應 Issue 描述(等下一小節接管理工具)

    3. 與 Linear / Jira 等管理工具整合

    重點不是「Claude Code 會寫 issue」,而是它能 自己對應任務 ↔ 代碼:

    • 典型流程:
    • 從 Linear / Jira 拉某個 issue 描述
    • Claude Code:
      • 解析需求
      • 找出相關檔案
      • 建議實作方案
      • 產生 patch / commit 訊息
    • 回寫到對應 issue(附 PR link、測試說明)
    • 這讓你可以用一句話驅動整個流程:
    • 「幫我處理 Linear 上 FE-1234 這張 ticket,照 acceptance criteria 寫完測試再開 PR。」

    行動建議:
    – 把團隊目前的 issue 模板、PR 模板貼給 Claude Code,請它:
    – 照樣學習格式
    – 以後所有「產生 PR 描述 / 測試計畫」都統一風格


    適合誰用?三種典型場景

    1. 單人開發者:讓 Claude Code 當你的 PM + Reviewer

    你一個人接案或做 side project,沒人幫你看架構、沒人幫你 review。Claude Code 可以扮演:

    • 專案 PM:
    • 幫你把「腦中需求」變成 roadmap:
      • 「這個月要完成:會員系統 v1、簡單報表」
    • 轉成 task list:db schema、API、UI、測試
    • code reviewer:
    • 每次 commit 前,請它檢查:
      • 功能風險
      • 重複邏輯
      • 可抽共用函式的地方

    具體做法:
    – 建立一個持續使用的 Claude Code 專案,放:
    – README、需求文件、todo list
    – 一份「我寫程式的偏好」(語言、框架、lint 風格)
    – 每天開工前一句:

    「根據目前 repo 與 TODO,幫我排今天 3 個最值得做的 task,控制在 3 小時內。」

    2. 小團隊:讓它維護 issue、測試、技術文件

    對 3–10 人團隊,Claude Code 好用在「把大家都懶得做的事」接走:

    💡 關鍵: 對 3–10 人的小團隊,把 issue 清理、測試補齊與文件生成交給 Claude Code,可顯著減少非核心開發時間。

    • Issue 維護:
    • 每週讓 Claude Code:
      • 清理過期 / 重複 issue
      • 把描述不清的 issue 重新改寫
    • 測試補齊:
    • 對於已存在的功能程式碼:
      • 要求它列出「目前缺哪些層級的測試」
      • 自動產生 test skeleton(unit / integration)
    • 技術文件:
    • 從 commit / PR 摘要產出:
      • 變更日誌
      • ADR(Architecture Decision Record)草稿

    具體做法:
    – 選一個模組先試點,例如「會員系統」:
    1. 把現有 PR、issue 歷史餵給 Claude Code
    2. 要它輸出一份「會員系統說明文件 v0」
    3. 團隊一起 review,修改後當作標準模板

    3. 大批量重構 / 遷移專案:讓它拆成可執行任務

    當你在做:
    – 從 JS → TS
    – 從 REST → GraphQL / gRPC
    – 從單體 → 模組化

    這時 Claude Code 的長上下文 + 任務拆解很實用:

    • 一次吃下:
    • 主要模組目錄
    • 現有測試
    • 部署設定
    • 輸出:
    • 分階段遷移計畫
    • 每階段具體改哪些檔、會壞掉什麼

    具體做法:
    – 問 Claude Code:

    「假設我要在 4 週內把 services/auth 從 JS 遷移到 TS,請在不影響現在線上環境的前提下,拆成 4 週計畫,每週列出可以單獨合併的 PR 列表。」


    怎麼開始:從註冊到跑完一條完整 workflow

    步驟 1:註冊與開啟 Claude Code

    1. 到 claude.ai 註冊帳號(可用 Google / Email)。
    2. 登入後,點右上角 Code 進入 Claude Code 介面。
    3. 建議準備:
    4. GitHub repo 連結
    5. 專案 README、需求文件

    步驟 2:連接 GitHub / 專案庫

    目前常見兩種用法:

    • 直接拖拉檔案夾:
    • 小專案、side project 最快
    • 接 GitHub:
    • 依照介面授權,把指定 repo 掛上去
    • 在對話裡直接叫它打開某個檔案路徑,再請它操作

    行動建議:
    – 先選一個風險較低的 repo(side project 或工具庫)當實驗場,不要一開始就丟公司核心系統。

    步驟 3:示範一條具體 workflow

    以「從 TODO issue → 產生 PR → 自動寫 release note」為例:

    1. 整理 TODO
      在 Claude Code 裡貼上:
    2. 一個 Linear / Jira issue 內容,或
    3. 散落在程式裡的 TODO 註解

    請它:

    「幫我把這些 TODO 整理成一個明確的 issue 描述,列出 acceptance criteria。」

    1. 讓它實作並產生 PR
      接著說:

      「根據這個 issue,在目前 repo 裡完成實作,請:1)列出要改的檔案 2)給我完整 patch 3)附上測試建議。」

    你可以:
    – 先人工 review patch
    – 把 patch 套進本地分支
    – 提交 GitHub PR

    1. 自動寫 release note
      PR 開好後,把:
    2. PR diff / 連結
    3. 關聯 issue 連結

    貼給 Claude Code,指令:

    「幫我寫一段 release note,給非工程同事看的,限制 150 字內,列出 2-3 個 bullet point。」

    若你有一份既有 release note 模板,也一起貼上,請它照模板格式輸出。

    做完一次,你就有一條可重複的最小 workflow,之後只要換 issue 就能重跑。


    進階玩法:把 Claude Code 變成「小開發團隊」的一員

    1. 和輕量模型分工,省錢跑批量任務

    很多工作不需要 Claude 這種大模型,例如:
    – 大量 JSON 重新排版
    – 批次分類檔案
    – 從文字裡抽欄位

    參考這篇 Reddit 實作:Most of my Claude usage was on work that didn’t need Claude

    做法:
    – 另外架一個便宜的小模型 API(例如 DeepSeek V4 Flash)
    – 在 Claude Code 這邊只放一個規則:
    – 「遇到格式轉換、摘要這種機械工作,一律呼叫那個外部工具,不要自己算」

    💡 關鍵: 把機械式任務交給便宜模型,可將大量批次任務成本壓到原本的約 1/10。

    效果:
    – 大量批次任務成本可壓到原本的 1/10 甚至更低

    2. 搭配 Relay 這類插件,讓多個 Claude Code 會話互通

    如果你常同時開:
    – 一個 session 管 backend
    – 一個 session 管 frontend
    – 另一個管 infra / CI

    可以照這篇的做法:built a plugin so my parallel Claude Code sessions can message each other

    概念是:
    – 用像 Relay 這種小工具,讓不同 Claude Code 視窗可以互相發訊息
    – 例如:
    – 前端 session 問:「User object 現在長怎樣?」
    – 後端 session 直接回,結果推回前端視窗顯示

    實際好處:
    – 你不用在多個對話間複製貼上
    – 等於有好幾個專職「子工程師」在各自 repo 幫你跑任務,互相同步狀態


    小結:把 Claude Code 視為「工作流 Agent」,不是「更聰明的 Copilot」

    使用 Claude Code 的關鍵心態是:
    – 不要只問「幫我寫這個 function」
    – 要改成「幫我把這個 issue 從需求 → 設計 → 實作 → 測試 → 文件,一次帶完」

    先從一條最小 workflow 開始做起(例如本文的 TODO → PR → release note),再逐步接上 issue 管理、測試、自動文件,Claude Code 才會真正變成你開發流程的一部分,而不是多一個可以聊天的 IDE 工具。

    🚀 你現在可以做的事

    • 選一個風險低的 repo,丟進 Claude Code,請它產出架構圖與技術債清單
    • 把現有的 issue / PR 模板貼給 Claude Code,讓它學會之後統一產生描述與測試計畫
    • 實做一次「TODO → issue → PR → release note」完整 workflow,確認能在團隊內重複使用
  • 白宮想先審模型?問題問錯了

    白宮想先審模型?問題問錯了

    📌 本文重點

    • 風險應鎖定「系統用途」,而非只看模型大小
    • 模型級事前審查恐強化巨頭壟斷與開源地下化
    • 高風險應用需系統級風控與用途分級監管
    • 監管若只管模型,AGI 軍備競賽將在黑箱中加速

    白宮打算對前沿 AI 模型事前審查,在政治上看起來是「負責任的創新」,但從產業與開發者視角來看,這更像是一種把風險簡化成『模型大小』的錯配治理。在高風險模型應被嚴管這點上,產業其實並不反對,真正的問題是:把關重心放在「模型本身」而不是「系統行為與用途」──會不會既管不好風險,也凍結了錯誤的環節?


    一、白宮看「模型」、五眼看「代理」:監管焦點正在錯位

    先看兩個同步發生的訊號:

    • 白宮討論的是:新一代大型模型(尤其是 frontier models)在發布前要不要先交政府審查,檢測危害能力、決定能不能上線。
    • 五眼聯盟(CISA、NCSC 等)最新的聯合指引,針對的卻是 agentic AI:多代理系統、自主工作流、具持續行動能力的 AI pipeline,明確要求企業在部署前優先考慮韌性與控制, 而不是生產力。

    這兩種路線反映的是兩個不同的威脅模型:

    1. 模型級風險敘事:
    2. 典型畫面是:一個超強模型,一次性釋出後就能讓駭客、恐怖分子瞬間升級。
    3. 治理直覺是:先審後放,像藥品或核能一樣,管住最大顆的東西。

    4. 系統與代理級風險敘事(五眼路線):

    5. 真正危險的不是「模型會回答什麼」,而是代理如何持續行動、調用工具、串接其他系統。
    6. 指引已經把威脅焦點,從單一 LLM 能力,移到「可自動執行任務、能自己發 API call、能在網路上持續探索」的整體系統。

    如果你在做 Agent pipeline,就會知道:

    同一個模型,丟在聊天機器人裡多半是 CSR 升級版;串上瀏覽器、交易 API、RPA、向量庫,再加個 loop,立刻變成「半自主決策系統」。

    從風險工程的角度,白宮現在盯的是錯誤層級。

    • 模型的「潛在有害能力」當然重要,但真正導致事故的,多半是:
    • 沒有限制的工具權限
    • 沒有監督的人機分工
    • 沒有審計的自動化決策鏈
    • 五眼的文件,本質上是在對企業說:「請準備好接受針對『系統行為』的合規審查。」

    💡 關鍵: 真正高風險多發點在「系統與代理行為」,而不是單一模型能回答什麼問題。

    這就是為何很多安全研究者一邊支持 Stuart Russell 對 AGI 軍備競賽的警告,一邊又對「模型級事前審查」保持保留:

    風險是真實的,但管錯層級,只會讓產業付出巨大成本,卻沒有相稱的安全收益。


    二、誰最愛模型審查?巨頭、開源與企業的三角張力

    從產業結構看,「模型級事前審查」直接重塑競爭版圖:

    1. 巨頭:安全、合規、護城河三合一

    對 OpenAI、Google、Anthropic、Meta 這類巨頭來說:

    • 合規成本:可以用數百人安全團隊、專職律師、外部第三方審查來消化,甚至變成 PR 資產——「看,我們是政府認證的安全實驗室」。
    • 監管內化成護城河:
    • 一旦 frontier models 必須事前審查,
    • 真正能玩得起的人,只剩少數幾家,
    • 監管變成規模經濟,新進者被擠在門外。

    這點在 Musk v. Altman 案件中看得很清楚:

    • Musk 指控 OpenAI 背棄非營利承諾,實質抱怨的是:OpenAI 變成了高度商業化 + 高度閉源 + 高度集權的 AI 供應商。
    • 但諷刺的是,一旦政府採用模型級事前審查,這種「昂貴、閉源、只有少數巨頭玩得起的模式」反而會被制度強化。

    2. 開源與中小實驗室:不是被管死,就是被推向灰色地帶

    對開源社群與中小團隊,模型審查是另一個故事:

    • 合規成本不成比例:
    • 你可能有能力在單一 A100 上訓一個 7B 模型,
    • 但你絕對沒能力維護一個能應付多輪政府審查的法務團隊。
    • 法規如果切在「參數規模/算力門檻」,看似只管最前沿,其實會:
    • 把很多有野心但沒預算的團隊,推往灰色與海外託管(繞到較寬鬆司法區訓練與發布)。
    • 鼓勵「算力打補丁」:大家拼命在可管制門檻以下做 model souping、蒸餾、長上下文、工具接入,風險依舊上升,但法律只看到「這不是 frontier model」。

    Local LLaMA 社群早就看出這個方向:

    當主權國家開始嚴控「模型發布」,真正的創新會往開源地下化、跨境部署、分散式訓練走,而不是乖乖排隊等審查。

    3. 企業用戶:安全感上升,靈活度下降

    對企業應用端來說,模型級審查有一好一壞:

    • 好處:
    • 上層管理層可以對董事會說:「我們用的是通過白宮審查的模型」,責任轉嫁變容易。
    • 在某些高風險領域(金融、醫療、關鍵基礎設施),這確實能提供更明確的責任邊界。
    • 壞處:
    • 合規是雙面刃,取得新模型的周期延長、選項變少,反而加強對少數供應商的鎖定。
    • 真正的風險——例如把模型接到內部交易系統、供應鏈決策、敏感客戶數據——仍然出現在系統設計與部署層, 而不是模型發布本身。

    如果你是企業技術主管,真正該問的不是「這個模型有沒有被白宮審過」,而是:

    我們的 agent pipeline、tooling、權限管理、審計與風控,有沒有對齊五眼那種系統級安全要求?


    三、當安全變成政治敘事:Musk、Altman 與 AGI 軍備競賽

    Musk v. Altman 訴訟與 Stuart Russell 對 AGI 軍備競賽的憂慮,表面上看是道德與安全之爭,實際上也在塑造監管框架的「敘事戰場」。

    • Musk 陣營:
    • 一方面在法庭上指責 OpenAI 背棄「造福人類」使命,
    • 一方面透過 xAI 積極追 frontier models,
    • 同時主張政府應嚴控其他實驗室,避免 AGI 軍備競賽失控。
    • Russell 作為 Musk 唯一的 AI 專家證人,強調政府要「約束最前沿實驗室」,避免 RSI(遞迴自我改進)引爆全球安全風險。

    把這些放進 Jack Clark 的判斷就更有張力:

    • 他認為 2027 年底 AI 能自動化 AI 研究機率約 30%,2028 年底超過 60%,也就是說:
    • frontier labs 很快可以用 AI 自己加速模型研發與訓練效率(報告中提到甚至高達 52 倍訓練效率提升)。
    • 一旦這種「AI 幫你造更強 AI」的 RSI 開始滾動,監管節奏就很難跟上。

    💡 關鍵: 若 AI 研發效率可能提升到「52 倍」,監管滯後的代價會被成倍放大。

    於是,我們看到三層混在一起的敘事:

    1. 政治:
    2. 白宮需要在「保護國家安全」與「維持科技領先」之間找到說得出口的姿態。
    3. 模型事前審查,對選民來說很好理解,遠比「我們要管 agent pipeline 的系統風險」好賣得多。

    4. 商業:

    5. frontier labs 一邊喊著安全,一邊積極構建「只有我們玩得起」的閉環——模型、資料、算力、合規一起變成壟斷資本。
    6. 模型級審查完美對齊這個商業結構。

    7. 安全:

    8. 嚴肅學者(如 Stuart Russell)真正擔心的是 全球性的 AGI 軍備競賽與 RSI,而不是單一 GPT-5.5 有多會寫程式。
    9. 但當這種抽象的長期風險,被翻譯成具體政策工具時,往往就被縮減為「管住最大顆的模型」。

    問題是:如果監管只剩「模型級審查」,那 AGI 軍備競賽只會從「沒管」變成「在少數國家與少數巨頭之間悄悄進行」。

    💡 關鍵: 一刀切的模型審查,可能只是把 AGI 軍備競賽推進更不透明、更集中化的黑箱。


    結論:支持嚴管高風險用途,反對一刀切模型審查

    綜合以上,合理的立場應該是:

    • 支持:對 高風險用途(金融交易、醫療診斷、關鍵基礎設施、軍事、選舉操控等)實施精準管制,
    • 要求系統級安全測試、審計、記錄、紅隊演練、責任追溯,
    • 對真正接近 RSI 或 AGI 能力的實驗室,施加額外的透明度與國際協調約束。
    • 質疑:以「參數規模/算力」或單一模型能力,作為事前審查的主要依據;這會:
    • 強化巨頭壟斷,
    • 把創新推向少數國家與黑箱實驗室,
    • 忽略系統與代理行為才是風險主戰場。

    對開發者與企業使用者,我的具體建議是:

    1. 把資源從「追最新模型」轉到「設計安全的系統」:
    2. 投資在權限分級、tool sandbox、可觀測性、審計 log、fail-safe 機制。
    3. 主動對照五眼的 agentic AI 指引,把它當成未來合規底線,而不是選配。

    4. 在組織內部建立「用途級風控」而非「模型級封殺」:

    5. 針對不同用途定義風險等級與流程,而不是僅僅禁止某些模型。
    6. 對高風險應用,預先準備內部審查機制,未來才能更平順接軌外部監管。

    7. 對監管參與發聲:要求以系統行為為單位的分級監管:

    8. 開發者社群、產業協會、企業技術主管,都應主動向政策制定者傳遞一個訊息:
    9. 真正需要的是「用途與系統級」的細緻分級,而不是對模型一刀切的事前審查制度。

    如果我們放任「模型級審查」成為預設答案,AI 的未來很可能會被鎖進少數實驗室與少數國家的鐵盒子裡;
    而一個真正安全、具有韌性且多元競爭的 AI 生態,正好需要相反方向:把監管精準落在系統行為、用途與部署場景上。

    🚀 你現在可以做的事

    • 實際檢查自家 agent pipeline(工具權限、審計 log、fail-safe)是否符合五眼對 agentic AI 的系統級安全指引
    • 在公司內部建立「用途級風控流程」,為高風險 AI 應用設計專門審查與紀錄機制
    • 透過產業協會或公共諮詢,向監管機關回饋:應將監管焦點放在系統行為與用途,而非單純模型大小