作者: kerwin77106

  • 把你的 Mac 變成本地 AI 工作站

    把你的 Mac 變成本地 AI 工作站

    想在 Mac 上跑 AI,又不想把程式碼、合約、研究資料傳到雲端?Conifer 要做的,就是把你的 Apple Silicon Mac 變成一台真正可離線工作的 AI 工作站。

    📌 本文重點

    • Conifer 把 Apple Silicon Mac 變成本地 AI 工作站
    • 支援本地檔案與應用程式存取,權限由系統控管
    • 開源免費 beta,適合開發本地 Agent 與高隱私場景

    專案連結:Conifer 在 r/artificial 的介紹


    核心功能:把「雲端用法」搬回本地

    1. 專為 Apple Silicon + Rust 寫的本地推論引擎

    Conifer 是一個用 Rust 寫的開源本地推論引擎,底層核心手寫優化,針對 Apple Silicon(M1 / M2 / M3)調教。

    能做什麼:
    – 在 M 系列 Mac 上,比一般沒調教的框架更穩定地跑小到中型 LLM
    – 同一台機器跑多個任務(寫程式、整理文件)時,效能比較不容易「卡住」

    💡 關鍵: 只要是 Apple M1/M2/M3 且有足夠記憶體,你就能在單機上穩定跑小到中型 LLM。

    你可以馬上採取的行動:
    – 檢查自己 Mac:
     > 關於本機 → 處理器是否為「Apple M1/M2/M3」
    – 記憶體至少 16GB8GB 也能跑小模型,但體驗會受限)

    2. 支援本地檔案 / 應用存取,搭配系統權限控管

    Conifer 的設計目標之一,是支援「本地 Agent」:
    – 可以讀寫你的本地檔案(PDF、Markdown、程式碼)
    – 可以呼叫本機應用(例如開啟檔案、寫入資料夾)
    – 權限由作業系統核心層強制管理,避免 AI 亂碰不該動的資料

    這意味著,你可以做:
    – 「幫我整理這個資料夾裡所有 PDF,產出一份摘要」
    – 「讀這個專案的程式碼,幫我改這支函式」

    你可以馬上採取的行動:
    – 想一個你願意讓 AI 自動操作的「專用資料夾」,例如:~/AI_workspace,等等示範 workflow 會用到。

    3. 開源、免費、適合做本地 Agent 原型

    依照開發者在 Reddit 上的說法:
    – 專案是開源、免費,會持續維持這個狀態
    – 團隊目前在招募約 100 位 beta 使用者,一對一協助寫工具、做效能調校

    💡 關鍵: 現階段參與 beta 可以免費獲得一對一協助,讓工具更貼近你的實際需求場景。

    你可以馬上採取的行動:
    – 如果你是開發者或技術使用者,可以考慮加入 beta:
    – 到 Reddit 貼文底下留言說明你的使用情境
    – 或看貼文中是否有 waitlist 表單連結(之後版本有可能會直接公開在 GitHub)


    適合誰用:三種典型場景

    1. 開發者:在本機跑程式碼助手 / 文檔 QA / 客服原型

    具體能做的事:
    – 在 VS Code / JetBrains 旁邊,跑一個本地程式碼助手
    – 把專案文件(Markdown、API spec)丟進一個資料夾,做「本地文件問答」
    – 跑一個簡單客服 bot 原型,用你自己的 FAQ PDF 當知識庫

    你可以馬上採取的行動:
    – 先挑一個你想用 AI 幫忙的專案:
    – 例如一個 Node.js 後端專案資料夾
    – 再準備一個 docs/ 放所有設計文件
    – 之後就能用 Conifer + 本地模型,對這個目錄做 Chat / 查詢。

    2. 內容創作者:離線寫作、改稿、摘要

    如果你常在咖啡廳、出差途中、或沒有穩定網路的地方寫作,Conifer 的價值很明顯:
    – 不連網也能:改寫段落、列大綱、做摘要、翻譯
    – 不用把稿件上傳到第三方雲端

    你可以馬上採取的行動:
    – 建立一個 ~/AI_workspace/articles/ 資料夾
    – 把你正在寫的文章 .md / .docx 匯出成 .txt.md 放進去
    – 稍後我們會示範 workflow:「請本地 AI 幫你整理這個資料夾裡所有文章」。

    3. 高隱私需求行業:法律 / 研究 / 內部知識庫 QA

    結合 Reddit 上法律工作者用本地叢集做草案撰寫的案例,可以把 Conifer 看成「單機版的縮小版叢集」:
    – 法律:讀本地條款、判決書、內部範本,生成草案初稿
    – 研究:整理本地 PDF 論文庫,做摘要、整理引用
    – 公司內部:拿內網手冊和 SOP 做 QA,不經任何雲端 API

    💡 關鍵: 對法律與企業內部知識庫場景,Conifer 讓資料全程留在內網與單機上更容易符合合規要求。

    你可以馬上採取的行動:
    – 準備一個「可以讓 AI 讀」的資料夾,例如 ~/AI_workspace/legal_docs/
    – 先只放不含敏感客戶資料的檔案,確認工具行為和權限再逐步擴大範圍。


    跟其他本地方案比,Conifer 的位置在哪?

    如果你已經在用像 Ollama 這類工具,Conifer 比較像是「更貼近系統、偏工程師向」的一層。

    名稱 核心功能 免費方案 適合誰
    Conifer Apple Silicon 本地推論引擎 + 本地 Agent 支援 開源免費 beta 想做本地 Agent、需要檔案/應用權限控制的技術用戶
    Ollama 一行指令拉模型、快速啟動本地聊天 開源免費 想快速在本機試模型、不需太深度系統整合的使用者

    補充:如果你要的是「只要打開就能聊」的體驗,Ollama 比較接近一般使用者工具;如果你想做「讀檔案、動應用程式」的本地 Agent,Conifer 會比較合適。


    怎麼開始:從安裝到第一次對話

    注意:目前 Conifer 正在 beta 階段,實際命令可能會隨版本調整,下列流程是給你一個「從 0 到能跑」的具體心智模型,細節以官方說明為準。

    步驟 1:從 GitHub 取得 Conifer

    1. 進入專案頁(之後應會公佈在 GitHub,現在可以先從 Reddit 貼文追蹤):
    2. Conifer 介紹貼文
    3. 找到:
    4. GitHub 連結
    5. 或 beta 測試申請表單
    6. 申請 beta:
    7. 簡單說明你的機器規格、預計使用情境(例如:本地程式碼助手 + 文件 QA)

    步驟 2:在 Mac 上安裝(示意流程)

    拿最典型的 CLI 安裝方式舉例,你可以預期會類似這樣:

    # 1. 安裝 Rust(若尚未安裝)
    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
    
    # 2. 從 GitHub clone 專案
    git clone https://github.com/<team>/conifer.git
    cd conifer
    
    # 3. 編譯執行檔
    cargo build --release
    
    # 4. 把執行檔加入 PATH(依專案說明為準)
    cp target/release/conifer /usr/local/bin/
    

    你可以馬上採取的行動:
    – 確認自己是否能順利用 cargo build 編譯一個 Rust 專案(沒問題的話,跑 Conifer 會順暢很多)。

    步驟 3:下載一個示範模型

    在 beta 階段,團隊通常會推薦一組「測試穩定」的小模型,方便你先確認引擎和權限系統是否正常。

    假設他們提供一個 qwen-3b-conifer.gguf 模型,你可以這樣做:

    mkdir -p ~/conifer-models
    cd ~/conifer-models
    curl -O https://models.conifer.ai/qwen-3b-conifer.gguf
    

    你可以馬上採取的行動:
    – 留意兩件事:Mac 的可用磁碟空間(模型可能是數 GB)、網路下載速度(第一次拉模型比較久)。

    步驟 4:跑起你的第一個本地對話

    完成模型下載後,啟動一個簡單的 CLI 對話伺服器,例如:

    conifer run \
      --model ~/conifer-models/qwen-3b-conifer.gguf \
      --mode chat
    

    接著在終端機輸入:

    你現在在我的 Mac 本機上跑,不連網路。請回覆「已啟動」,並告訴我你能幫我做什麼。
    

    如果模型正常回覆,代表:
    – 推論引擎 OK
    – 模型載入 OK
    – 不需任何雲端 API,就能跑起一個基本聊天助手


    示範 workflow:本地 AI 幫你整理指定資料夾文件

    下面是一個你可以實際用得上的簡單 workflow,示意 Conifer 的「本地檔案 + 權限」能力。

    目標

    給 Conifer 一個資料夾路徑,讓它:
    1. 掃描裡面的 .txt / .md 檔案
    2. 為每個檔案產一段摘要
    3. 輸出成一個 summary.md 報告

    準備

    1. 建立資料夾:
      bash
      mkdir -p ~/AI_workspace/articles
    2. 放入幾個測試檔案 article1.md, article2.md

    可能的 Conifer Agent 方式(概念示例)

    未來 Conifer 會提供類似「工具 + 權限」的設定,你可以:

    1. 在設定檔中開啟檔案系統工具,限定路徑:
      toml
      [tools.files]
      enabled = true
      allowed_dirs = ["/Users/你/AI_workspace/articles"]
    2. 啟動一個「文件整理 Agent」:
      bash
      conifer run \
      --model ~/conifer-models/qwen-3b-conifer.gguf \
      --agent file-summarizer.toml
    3. 發出任務:
      text
      請在 /Users/你/AI_workspace/articles
      讀取所有 .md 檔案,為每個檔案產 3–5 行摘要,
      把結果整理成一個 summary.md 存在同一個資料夾。

    這個流程的重點是:
    – 檔案存取範圍你自己限制
    – AI 只在你指定的資料夾裡讀寫
    – 全程在你的 Mac 上完成,不透過外部伺服器

    你可以馬上採取的行動:
    – 先想清楚:你願意開放給 AI 長期讀寫的 1–2 個「工作資料夾」,其他一律不給權限。


    Beta 現況:怎麼加入與回饋問題

    依照 Reddit 貼文資訊,Conifer 團隊目前:
    – 正招募約 100 位免費 beta 使用者
    – 會跟這些使用者一對一合作:了解需求、寫專用工具、做效能最佳化

    你可以這樣參與:

    1. 到這篇 Reddit 貼文:
      👉 Building Conifer, an open-source local inference runtime
    2. 在留言中說明:
    3. 你的機器(例如:M2 Pro + 32GB RAM
    4. 你打算怎麼用(例如:本地程式碼助手 + 法律文書草案)
    5. 開始測試後,把你遇到的:
    6. Crash log
    7. 效能瓶頸(例如某模型載入太慢)
    8. 需要的工具(例如:想要一個自動讀 PDF 的工具)
      回報給開發團隊

    這樣做的好處是:
    – 你可以在第一時間拿到更穩定、貼近實務需求的版本
    – 你的需求(例如法律、研究場景)會直接影響這個本地 AI 引擎未來的功能優先順序


    如果你已經習慣雲端模型的便利,下一步值得嘗試的,就是把其中一個工作流程搬回本地,在自己的 Mac 上用 Conifer 跑一次,感受「完全不經過網路」的 AI 工作站體驗。

    🚀 你現在可以做的事

    • 檢查自己的 Mac 規格(Apple M 系列 + 至少 16GB RAM),並預留數 GB 空間放模型
    • 建立一個 ~/AI_workspace/,準備好願意給 AI 操作的專用資料夾與測試文件
    • 前往 Reddit 貼文關注 Conifer 專案進展,視需求申請 beta 並規劃你的第一個本地 Agent 用例
  • 把 Claude 變成你的主力工作代理人

    把 Claude 變成你的主力工作代理人

    📌 本文重點

    • 把 Claude 當「可配置代理人」,而非一次性問答工具
    • 善用 Claude.md、Skills、Subagents、Plugins 建立工作流程
    • 針對身份配置專屬 workflow,讓重複工作自動化

    一句話定位:不是再多寫一個 prompt,而是把 Claude 配好「記憶+流程+工具」,變成每天幫你跑任務的主力工作代理人。


    核心功能:先理解這 4 個積木

    目標:看完這一節,你要能說出「Claude 現在在哪裡記東西、怎麼做事、怎麼叫外部工具」。


    1. Claude.md:給代理人一個「長期腦袋」

    • 角色:你的私人知識庫與工作說明書(system prompt 的升級版)。
    • 放什麼:
    • 你的背景(職位、產業、常用技術棧)
    • 任務偏好(寫作語氣、程式碼風格、專案管理習慣)
    • 長期專案的關鍵資訊、慣用模板
    • 使用效果:每次新對話,Claude 自動帶著這份設定,不用再重複解釋自己。

    💡 關鍵: 善用 Claude.md,可以一次設定、長期沿用,省去每次從零解釋背景與偏好的時間成本。

    可以馬上做的事:

    1. claude.ai 登入。
    2. 在設定或 Workspace 設定裡找到 Claude.md 或類似「AI 配置檔」。
    3. 寫第一版內容(建議結構):

    “`markdown
    # 關於我
    – 角色:B2B SaaS 產品經理
    – 常用語言:繁體中文 + 英文技術文件

    # 工作偏好
    – 寫作:偏實用教學,少形容詞,多步驟
    – 文件格式:盡量用 Markdown,標題層級清楚

    # 長期專案
    – 專案 A:AI 產品內部知識庫
    – 專案 B:每週技術選型評估報告
    “`

    1. 日後只要養成習慣:有長期沿用的規則/資訊,就補進 Claude.md,而不是每次對話再講一次。

    2. Skills:可重用的「任務模板」

    • 角色:把你常做的工作,變成一顆一鍵呼叫的小程式。
    • 適合類型:
    • 每週重複的報告(例:每週產品更新摘要)
    • 固定格式的輸出(例:Code review 指南、文章大綱格式)
    • 需要多步驟的任務(例:先讀文件 → 列出問題 → 提出修改建議)

    一個簡單 Skill 範例:專案讀書筆記器

    邏輯:給 Claude 一篇文章連結或貼上內容,Skill 幫你產出固定結構的筆記。

    Skill 內容可以長這樣(概念示意):

    # 技能名稱:research_note
    
    ## 功能
    將一篇文章整理成結構化研究筆記。
    
    ## 輸入
    - `content`: 文章全文或重點摘錄
    
    ## 任務步驟
    1. 先用 3 句話摘要內容。
    2. 條列:關鍵概念、重要數據、引用來源。
    3. 給出:
       - 對我目前專案的啟發
       - 後續可以延伸研究的 3 個問題
    
    ## 輸出格式
    使用 Markdown:
    - 概覽
    - 關鍵概念
    - 數據與引用
    - 對專案的啟發
    - 後續問題
    

    可以馬上做的事:

    1. 在 Claude 介面中找到 Skills(通常在左邊或設定的 Skills / Tools 區)。
    2. 新增一個 Skill,把上面範例貼進去並調整成你的語氣與領域。
    3. 之後看到文章,直接對 Claude 說:

    research_note 幫我整理這篇,內容在下面:


    3. Subagents:把大任務拆給專職小幫手

    • 角色:一個大代理人(你平常在聊的 Claude),底下可以派出「專職分身」。
    • 適合情境:
    • 寫作:資料研究 agent、結構調整 agent、潤稿 agent 各司其職
    • 工程:debug agent、測試覆蓋率 agent、文件撰寫 agent
    • 專案管理:需求整理 agent、風險盤點 agent、會議紀錄 agent

    參考 多代理系統實作文章 的做法,你可以這樣配置:

    • ResearchAgent:只負責找資料、整理重點,不下結論。
    • WriterAgent:只根據整理好的重點寫初稿。
    • EditorAgent:只負責風格、語氣、構優化。

    可以馬上做的事:

    1. 在 Skills 區先各自為 researchwriteedit 建立對應 Skill。
    2. 建一個「總控 Skill」,流程像這樣:

    markdown
    1. 呼叫 ResearchAgent Skill,輸入主題。
    2. 將輸出傳給 WriterAgent Skill,生成草稿。
    3. 將草稿丟給 EditorAgent Skill,優化文稿。

    1. 你對 Claude 下命令就只剩一句:

    用你的寫作工作流幫我處理這個主題:XXX

    這呼應了「Plan 模式比一次搞定更重要」的思路(可參考 這篇 Plan mode 深入解析)。


    4. Plugins / MCP:把 Notion、GitHub、日曆接進來

    • Plugins(或 MCP 伺服器):讓 Claude 能「去別的服務做事」,而不是只在聊天室輸出文字。
    • 常見接法:
    • Notion:讀寫頁面、幫你整理研究筆記
    • GitHub:查 issue、看 PR、寫 review 建議
    • 日曆:生成待辦、排會議時間

    可以馬上做的事:

    1. 在 Claude 設定中找到「Plugins」或「MCP」管理頁面。
    2. 授權你常用的工具(例如 Notion / GitHub)。
    3. 測試一個實用指令:
    4. Notion:

      幫我把這篇研究筆記整理成 Notion 新頁面,放在資料庫「AI Research」底下。

    5. GitHub:

      幫我看這個 PR,先列出潛在風險,再寫一段給同事看的 review。連結在這裡:XXX


    適合誰用:3 種典型配置範例

    目標:對照自己的身份,直接抄一套設定起來。


    1. 個人工作者:寫作 / 研究 / 專案管理

    建議配置:

    • Claude.md
    • 明確定義你的寫作風格、常用結構(例如所有教學文都用「背景 → 步驟 → 範例 → 常見錯誤」)。
    • Skills:
    • research_note:文章/論文筆記
    • outline_builder:輸入主題,自動給 2–3 個不同角度的大綱
    • meeting_minute:貼原始會議筆記,輸出「決策/待辦/風險」三欄
    • MCP / Plugins:
    • Notion 或 Obsidian 相關工具,讓筆記自動進入你的知識庫。

    日常 workflow 範例:

    1. 丟 3–5 篇相關資料給 Claude,用 research_note 各自整理。
    2. outline_builder 產出文章大綱,選一版改一改。
    3. 完稿後請 Claude 依指定格式,寫成 Notion 新頁面並歸檔。

    2. 工程師:Code Review + 多 repo 協作

    建議配置:

    • Claude.md
    • 寫清楚專案技術棧、程式碼風格規範、測試原則。
    • Skills:
    • code_review:給 PR 連結或 patch,輸出:問題清單、風險點、建議 commit 清單。
    • test_case_generator:根據函式/API,幫你列出缺的測試案例。
    • Subagents:
    • ArchitectureAgent:只看架構與邏輯。
    • StyleAgent:只看命名、風格、一致性。
    • MCP / Plugins:
    • GitHub / GitLab 工具,直接讀 PR diff、issue 歷史。

    日常 workflow 範例:

    1. 對 Claude 說:

    幫我用你的 code_review 工作流檢查這個 PR:XXX

    1. Claude 讀 GitHub diff,先由 ArchitectureAgent 看設計,再由 StyleAgent 補充風格問題,最後合併成一份可直接貼回 PR 的 review。

    3. 小團隊:共用一組技能與工作流

    建議配置:

    • 共用 Workspace 的 Claude.md
    • 放團隊寫作規範、技術決策原則、產品定位。
    • 共用 Skills:
    • weekly_update:所有人都用同一個模板輸出週報。
    • spec_template:PRD / 技術規格文件的標準結構。
    • MCP / Plugins:
    • 共用的 Notion、Jira、GitHub 專案權限。

    操作方式:

    1. 由一人負責整理團隊的 Claude.md 和 Skills。
    2. 其他成員只需要:
    3. 在週報時輸入:

      weekly_update 幫我整理這週的進度,重點在 XXX。

    4. 寫新功能時:

      spec_template 幫我產生這個功能的 PRD 初稿,功能說明如下:XXX。


    一小時內用起來:實戰 workflow 示範

    目標:照這段做完,你就有「從資料收集 → 產出大綱 → 自動整理到知識庫」的一套日常代理人流程。


    Step 1:開啟並寫好第一版 Claude.md(10 分鐘)

    1. 打開 claude.ai → 設定 → Claude.md
    2. 貼入這個模板再依需求修改:

    “`markdown
    # 關於我
    – 角色:__
    – 主要領域:
    ____

    # 工作偏好
    – 回覆語言:繁體中文
    – 文件格式:預設使用 Markdown
    – 風格:先給結論,再拆解步驟

    # 長期專案
    – 專案 1:__(簡述目的與目前進度)
    – 專案 2:
    ____
    “`


    Step 2:建立第一個 Skill:研究筆記(10 分鐘)

    1. 到 Skills 管理頁,新增 Skill research_note
    2. 使用前面提供的 research_note 範本,改成你的領域語氣。
    3. 找一篇你最近在看的文章,把內容貼給 Claude,指定使用 research_note

    Step 3:讓 Subagent 接手子任務:大綱生成(15 分鐘)

    1. 新增 Skill outline_builder,內容類似:

    “`markdown
    # 技能名稱:outline_builder

    ## 功能
    針對一個主題,產生 2–3 個不同角度的大綱,每個大綱最多 5 個主標。

    ## 步驟
    1. 簡要理解主題與目標讀者。
    2. 提出 2–3 種切入角度。
    3. 針對每種角度,列出主標與一句說明。
    “`

    1. 建立一個「寫作工作流 Skill」,流程:
    2. 先呼叫 research_note 消化資料。
    3. 再把研究結果摘要丟給 outline_builder
    4. 你只要給主題 + 資料清單,就能一次拿到整理後的研究+多版本大綱。

    💡 關鍵:research_note + outline_builder 串成 workflow,一次輸入主題就能從資料整理到多版本大綱,大幅降低起稿門檻。


    Step 4:接上 Notion,自動寫入知識庫(15–25 分鐘)

    1. 在 Plugins / MCP 介面中,啟用 Notion 並完成授權。
    2. 建一個 Notion 資料庫,叫做「AI 研究庫」。
    3. 對 Claude 下指令:

    從現在開始,所有用 research_note 產出的內容,幫我整理成 Notion 新頁面,放在「AI 研究庫」,標題用日期+主題。

    1. 測試一次完整流程:
    2. 丢一篇文章 → 用 research_note 整理。
    3. 要求 Claude 寫入 Notion。
    4. 打開 Notion 確認格式與欄位是否符合期待,必要時微調規則。

    延伸工具:如果想把多個 AI 輸出集中管理

    如果你平常 Claude / ChatGPT / Gemini 都會用,可以考慮配合像 Coffer 這類工具,把所有 AI 回覆存進一個可搜尋的 vault(原作者分享在 Reddit)。

    名稱 核心功能 免費方案 適合誰
    Claude 主力工作代理人:Claude.md + Skills + MCP 想把 AI 當長期工作夥伴的人
    Coffer 儲存多家 AI 回應到本地可搜尋知識庫 重度問 AI、怕內容散佈的人

    💡 關鍵: 把多家 AI 的回應集中到同一個可搜尋知識庫,可以避免資訊分散在不同聊天裡,長期累積成真正可用的資產。


    只要先把 Claude 當成「可以配置的代理人」,而不只是「一次性的問答工具」,從 Claude.md、Skills 到 Subagents、Plugins 一步步搭起來,你就會開始感受到:每天重複的工作,有越來越多可以丟給它接手。

    🚀 你現在可以做的事

    • 登入 claude.ai,建立並填好你的第一版 Claude.md
    • 新增一個 research_note Skill,實際拿一篇文章讓 Claude 幫你整理研究筆記
    • 啟用 Notion 或 GitHub Plugin,測試一次「從 Skill 輸出到外部工具」的完整工作流
  • 讓 Claude 幫你刷卡之前:誰在替 Robinhood 扛風險?

    讓 Claude 幫你刷卡之前:誰在替 Robinhood 扛風險?

    📌 本文重點

    • Robinhood 把可被遠端操控的 AI 代理直接接到刷卡與交易權限
    • 平台用技術切割資金,卻刻意模糊責任邊界與風控機制
    • 在可稽核帳本、細粒度授權與責任分攤未到位前,不該放手讓 AI 動真錢

    Robinhood 把 Anthropic 的 Claude 接到刷卡與下單權限上,不只是「又一個酷炫 feature」,而是第一次把「可被遠端操控的 AI 多代理系統」直接連到零售金融與消費支付。 這一步在技術上順理成章,在風險上卻是把本來應該由平台與監管承擔的系統性風險,轉嫁給最末端的散戶與一般用戶。


    一、從「聊天」到「刷卡」:Robinhood 正在測試的邊界

    先把產品拆開看:

    • 多代理 / MCP 架構:Robinhood 讓你把像 Claude 這類 AI agent 接到一個獨立投資帳戶與專屬錢包,透過 MCPModel Context Protocol)調用券商、信用卡等工具。
    • 資金層級的授權
    • 股票:agent 可以在這個帳戶裡 自動買賣,實現「agentic trading」。
    • 消費:部分實作更允許 agent 用你的 信用卡進行購物與支付
    • 風險切割的說法
    • Robinhood 對外主打「獨立帳戶」「預置資金上限」來降低風險。
    • 同時又提醒這不適合所有用戶,投入資金可能完全損失。

    💡 關鍵: 把可被 prompt 操作與攻擊的軟體代理接到真實刷卡與交易權限上,讓最末端用戶承擔原屬於平台與監管的系統性風險。

    表面看起來像是更自動化的量化交易 + 智慧消費,實際上 Robinhood 做的是:

    把一個可被 prompt、可被攻擊、可被他人操縱的軟體代理,直接掛到合規要求最嚴格的金融與支付基礎設施上,卻沒有同步升級責任、稽核與安全模型。

    這才是這件事真正危險的地方。


    二、「誰負責」被刻意模糊:合約寫得清楚,責任卻寫得含糊

    AI 代理進入金融業,第一個問題本來就應該是:誰為它的行為負責?

    Robinhood 用了幾個典型的模糊技術:

    1. 產品語言把責任推回使用者

    在宣傳裡,agent 被描述為「幫你監控產業、重新平衡投組的自動化工具」。聽起來像智能助理,但實際權限是 直接下單、直接刷卡。當代理做出離譜交易時,平台可以輕易退回一句:「是你授權的策略與 agent。」

    1. 技術結構被包裝成風險隔離,而不是責任分攤

    2. 「獨立帳戶」「預置錢包」的確在損失金額上畫了邊界。

    3. 但在責任邊界上卻沒有任何清楚設計:

      • 若因為 agent 被投毒、或底層依賴的 開源框架漏洞(如 Starlette 那類事件) 導致憑證外洩,誰買單?
      • 若 Claude 的模型行為偏誤,導致系統性錯誤交易,Anthropic、Robinhood、用戶各自的責任比例是什麼?
    4. 監管空窗下的「默許」創新

    美國 FINRA 已經點名 agentic trading 是新風險區,但現有規範多針對:

    • 人為操盤、演算法交易、黑箱策略披露。

    對於「由第三方大模型驅動、由多代理協調、可跨場域調用支付工具」這種架構,責任主體適格性審查都還沒寫進條文裡。

    實務上,這會導致一個非常實際的結果:

    出事時,平台可以拿出一疊風險揭露文件;模型公司可以引用使用條款;真正實際承受金錢損失與信用風險的,是那個按下「同意授權 AI 代理」的普通用戶。


    三、風控與 IR Playbook 還停留在「伺服器時代」,沒人真的在看代理行為

    把資安與風控角度拉進來,問題更明顯。

    Sygnia 2026 CISO 調查的幾個數字很關鍵:

    • 73% 的 CISO 認為組織還沒準備好應對重大攻擊
    • 約三分之一 覺得自己能妥善調查「AI 代理事件」。
    • 88% 部署 AI 代理的企業 在過去 12 個月有確認或疑似相關資安事件。

    💡 關鍵: 即使在專業組織中,仍有 73% 的 CISO 自認無法應對重大攻擊,顯示整體安全治理遠落後於 AI 代理實際授權範圍。

    原因很直接:

    過去的事件應變流程(IR playbook)是為「伺服器被入侵、帳密被盜」設計的,不是為「一群會互相對話、會記住憑證、會自己下單的代理」設計的。

    AI 代理具備幾個讓傳統風控失效的特徵:

    • 跨會話保存憑證與記憶:代理可以在很多天、很多任務裡重複使用同一組 API keysession,讓憑證洩漏的危害時間大幅拉長。
    • 自然語言互動易被投毒:系統不再只看 IP 與封包,而是要看「這段對話是不是惡意引導」,大多數 SOC 與風控系統根本沒這個能力。
    • 多步驟、自主規劃:代理可以自行「發現新工具 → 取得更多權限 → 發送轉帳指令」,整個路徑在傳統監控裡看起來都「合法」。

    再把 開源供應鏈風險 疊上來:

    • Starlette 漏洞 事件提醒我們:一個在 FastAPI、生態工具中被廣泛採用的 ASGI 框架出 bug,就能讓跑在上面的 數百萬 AI 代理與 MCP 工具暴露憑證與數據
    • 金融代理通常會握有:
    • 券商 API token
    • 銀行帳戶存取權
    • 信用卡支付憑證

    在這種結構下讓代理去刷卡、去下單,本質上是在做一件事:

    把交易與支付風險,疊加在一個安全治理成熟度遠低於傳統金融核心系統的「新技術堆疊」上。

    Google Cloud COO Francis de Souza 最近說「AI 安全應該進董事會,不只是機房」,Robinhood 這類產品設計,正好反向佐證:

    • 產品與增長團隊把 AI 代理視為「新的 engagement tool」。
    • 但多數公司的董事會與風控委員會,根本沒把「自主 AI 行為」列為一級風險源。

    四、從券商複製到 BNPL:系統性風險會沿著產品抄作業

    Robinhood 的這一步,一旦被證明「有黏著度、有交易量」,會很快被其他玩家複製:

    • 券商與新創銀行
    • 讓 agent 幫你做期權策略、槓桿 ETF 調倉。
    • 把「日內交易 + AI」包裝成散戶可享的量化工具。
    • 電商與信用卡發卡行
    • 「幫我自動 re-order 最划算的日用品」→ 背後其實是 agent 掌控你的卡號與地址。
    • 「自動比價 + 下單」→ 只差一個 prompt injection 就變成攻擊者的洗錢工具。
    • BNPL(先買後付)與小額信貸
    • agent 可以根據「你的消費習慣」幫你評估要不要分期、要不要借款。
    • 一旦信用決策與自動下單綁死,等於允許一個黑箱模型代理,替你在負債表上簽名。

    這裡的系統性風險不在於「一個人被盜刷」,而在於:

    1. 同一類 prompt injection / 供應鏈漏洞,可以同時打到成千上萬個代理,造成大規模同步錯誤交易與支付。
    2. 當越來越多資金流與風險決策被委託給代理,人類使用者變成「最後一個知道發生什麼事的人」,卻還要承擔大部分合約責任。

    從監管角度看,EU AI Act 已經給出一個方向:

    • 法案不只管 AI 開發團隊,更會沿著 供應鏈往上游追責
    • 未來若一個高風險 AI 系統(金融風險明顯屬此類)出了問題,
    • 提供模型的、
    • 提供代理框架與工具的、
    • 提供終端金流與硬體的,
      都可能被拉進責任鏈。

    這跟現在 Robinhood 模式形成強烈對比:

    產品端快速把授權往下推給用戶,監管端卻開始試圖把責任往供應鏈上收。中間這段空窗,就是最大風險區。


    結語:在三件事到位之前,AI 代理不該直接動你的錢

    從產業方向來看,Robinhood 的產品路線是不可逆的:AI 代理遲早會變成金融與支付的主流介面,就像當年 API 自動交易終究打敗電話下單。但現在的問題是節奏:責任與安全機制完全跟不上授權範圍。

    對開發者與產品決策者,我的具體判斷是:

    在以下三件事沒有設計清楚之前,不應該讓 AI 代理直接動用真實個人資金──更不要是信用卡與負債工具。

    1. 可稽核、可追溯的「代理行為帳本」

    2. 每次代理下單、調用支付、調整策略,都要有 結構化 log:觸發來源、工具、金額、模型版本、關鍵 prompt。

    3. 必須能在事後重建「這筆錢是怎麼被花掉的」,讓用戶、監管與第三方稽核都看得懂。

    4. 一鍵撤銷的細粒度授權機制

    5. 不只是「停用這個 agent」,而是:

      • 可限制交易品種(例如只能買 ETF,不可買期權)。
      • 可設定金額、頻率上限。
      • 可精準撤銷某個工具(例如暫停用信用卡,但保留投組分析)。
    6. 明確的賠償與責任分攤制度

    7. 對於模型錯誤、供應鏈漏洞、平台控管失當,要有清楚的賠償條款,而不是通通寫進「你已理解風險」。

    8. 用戶應該知道:什麼情況算是「你自己策略的錯」,什麼情況算是「系統或模型方的責任」。

    在這三件事落地之前,把刷卡權、交易權交給 AI 代理,本質上就是:

    把系統風險外包給缺乏談判能力與專業知識的散戶與一般消費者。

    身為開發者,你要做的不是搶先在首頁掛上「支援 AI 代理」,而是先問一句:如果這個代理瘋狂買進錯誤資產或被攻擊者操控,我們願意賠到什麼程度?
    如果這個答案說不出口,那就代表產品還沒準備好讓 AI 幫任何人刷卡。

    🚀 你現在可以做的事

    • 審視自己產品中所有 AI 代理權限,列出「能動哪些錢」「持有哪些憑證」並盤點風險
    • 為現有或規劃中的金融 / 支付代理設計「行為帳本」與「一鍵撤銷」機制雛形
    • 檢查條款與風險揭露文件,明確標示模型錯誤與供應鏈漏洞時的平台與用戶責任邊界
  • LLM × sktime craft 打造 AutoForecast

    LLM × sktime craft 打造 AutoForecast

    📌 本文重點

    • sktime + craft() 讓 LLM 設計可訓練的預測 pipeline
    • 以 LLM 當 search policy,降低傳統 AutoML 搜尋成本
    • 把業務限制寫進 prompt,兼顧準確度、延遲與維運

    傳統做時間序列 AutoML,多半靠 grid search / Bayesian search 把模型和超參數「全掃一輪」,成本高、速度慢,而且一換業務場景就得重調。這篇要介紹的是:用 sktime 的 pipeline + craft() 介面,讓 LLM 充當預測藍圖設計師,自動組裝可訓練、可回測的 forecasting pipeline,實際解決:

    • 算力被 AutoML 搜尋吃光的問題
    • 每個產品線都要單獨手調模型的維護地獄
    • 新資料來時,預測流程很難「可重現、自動化演進」的痛點

    重點說明

    1. sktime pipeline + craft():把「模型設計」變成文字介面

    sktime 提供了時間序列專用的 pipeline / composer 抽象,可以把:

    • 前處理(差分、假日特徵、滯後特徵)
    • 模型本體(ARIMA、Gradient Boosting、機器樹、深度模型包裝器)
    • 聚合、多變量等

    組成一個可訓練的 forecaster 物件

    craft() 的角色:

    • 接收一段以文字描述的「藍圖」或結構化 blueprint
    • 解析成真正的 sktime pipeline 物件
    • 後續你可以直接 .fit() / .predict() / 做交叉驗證

    💡 關鍵: craft() 讓「文字藍圖」直接變成可訓練的 sktime pipeline,是把 LLM 接到 AutoForecast 流程的關鍵樞紐。

    這讓 LLM 可以只負責「寫藍圖」,而不是直接產生一大段 Python 亂碼。


    2. 為什麼用 LLM 當 search policy,而不是再做一個 AutoML

    傳統 AutoML:

    • 先定義 search space(例如 10 種模型 × 10 個超參數 × 若干取值)
    • Grid/Bayesian 搜尋會盲目探索大量組合

    LLM 驅動 AutoForecast 的思路:

    • 你提供:資料描述、目標、限制條件、白名單元件
    • LLM 輸出:一個「專家風格」的 pipeline blueprint
    • sktime craft():把 blueprint 變成真正的 estimator
    • 之後用交叉驗證 + 回測,打分這個藍圖好不好

    好處:

    • 搜尋空間更有結構:LLM 預先排除很多不合理組合
    • 成本可控:每次只訓練少數幾個「有合理解釋」的藍圖
    • 你可以 固化得分高的藍圖,變成穩定的產線預測器

    💡 關鍵: 相較於暴力掃描大量組合,讓 LLM 先縮小「合理藍圖集合」,能在相同算力下探索更有價值的模型設計。


    3. 把業務限制寫進 prompt:準確度只是其中一個目標

    在實務專案中,像房地產、銷售預測一樣,除了誤差小,你還會在乎:

    • 推理時間(每天要跑上千條 SKU / 房源)
    • 部署複雜度(不要依賴罕見套件或 GPU)
    • 解釋性(要能向業務說明為什麼預測變化)

    這些都可以在 prompt 中顯式告訴 LLM,例如:

    • 限定只能用某些 estimator:NaiveForecaster, ExponentialSmoothing, ElasticEnsemble, LightGBM-based forecaster...
    • 給出目標指標:sMAPEMAE,並設計多目標(準確度 + latency)

    實作範例:銷售時間序列 LLM AutoForecast

    以下示範一個簡化版流程:

    • 場景:預測未來 3 個月每月團隊銷售額
    • 資料:月度歷史 revenue、房源數量、成交率、利率、季節 dummy 等

    假設你已經載入 sktime 與一個 LLM SDK(例如 Anthropic、OpenAI 等)。以下程式碼偏 pseudo,但結構可直接套入專案。

    1. 描述資料與目標,建立 LLM prompt

    schema_description = {
        "frequency": "M",  # 月度資料
        "target": "team_gci",  # 團隊佣金收入
        "horizon": 3,  # 預測 3 個月
        "exogenous_features": [
            "active_listings",     # 有效掛牌數
            "pending_transactions", # 待成交案件
            "mortgage_rate",      # 抵押貸款利率
            "seasonality_flags"   # 季節性特徵
        ],
        "constraints": {
            "max_pipeline_depth": 4,
            "allowed_estimators": [
                "NaiveForecaster",
                "ExponentialSmoothing",
                "ThetaForecaster",
                "LightGBMForecaster"
            ],
            "allowed_transformers": [
                "Detrender",
                "STLTransformer",
                "Lag",
                "DateTimeFeatures"
            ],
            "primary_metric": "sMAPE",
            "secondary_metric": "latency_ms",
            "max_fit_time_minutes": 15
        }
    }
    
    system_prompt = """
    你是一位時間序列預測專家,負責設計 sktime 預測 pipeline。
    
    要求:
    1. 只使用以下白名單中的 estimator 和 transformer。
    2. 避免過度複雜的 pipeline,深度不超過 4 層。
    3. 避免使用不存在的類別和參數,嚴格遵守 sktime API。
    4. 針對月度房地產團隊銷售數據,考慮趨勢與季節性。
    5. primary metric 是 sMAPE,次要考慮推理延遲,盡量用輕量模型。
    
    輸出格式:只輸出 JSON,欄位為 `pipeline_spec`,不可包含其他文字。
    `pipeline_spec` 要能被 sktime.craft() 解析。
    """
    
    user_prompt = f"資料與限制如下:\n{schema_description}\n請產生 pipeline_spec。"
    

    2. 呼叫 LLM,取得 pipeline blueprint

    from some_llm_client import LLM
    
    llm = LLM(api_key="...")
    
    response = llm.chat(
        system=system_prompt,
        user=user_prompt
    )
    
    blueprint = response["pipeline_spec"]  # 假設已解析 JSON
    print(blueprint)
    

    例:LLM 可能輸出類似(簡化)

    {
      "type": "TransformedTargetForecaster",
      "steps": [
        {"name": "detrend", "class": "Detrender", "params": {"forecaster": "NaiveForecaster"}},
        {"name": "stl", "class": "STLTransformer", "params": {"seasonal": 7}},
        {"name": "lag", "class": "Lag", "params": {"lags": [1, 2, 3, 6, 12]}},
        {"name": "model", "class": "LightGBMForecaster", "params": {"num_leaves": 31, "learning_rate": 0.05}}
      ]
    }
    

    💡 關鍵: 藉由 max_pipeline_depth = 4、白名單與 max_fit_time_minutes = 15 等約束,LLM 被強迫產出既合理又可在時限內完成訓練的藍圖。

    3. 用 craft() 轉成可執行 pipeline

    from sktime.craft import craft
    
    # 這裡的 blueprint 就是上一步 LLM 回傳的 JSON
    forecaster = craft(blueprint)
    
    print(type(forecaster))
    # e.g. <class 'sktime.forecasting.compose._pipeline.TransformedTargetForecaster'>
    

    如果 LLM 有亂給不存在的 class/參數,這一步會直接爆掉,所以建議外面包一層驗證:

    def safe_craft(blueprint):
        try:
            return craft(blueprint)
        except Exception as e:
            # 記錄錯誤,丟回給 LLM 做自我修正或直接丟棄該藍圖
            print("Invalid blueprint:", e)
            return None
    
    forecaster = safe_craft(blueprint)
    if forecaster is None:
        # 重新請 LLM 生成,或 fallback 到手寫 baseline
        ...
    

    4. 做時間序列交叉驗證與回測(避免 leakage)

    時間序列不能隨機 shuffle,必須用 滾動時間窗

    from sktime.forecasting.model_selection import ExpandingWindowSplitter
    from sktime.performance_metrics.forecasting import mean_absolute_percentage_error
    
    cv = ExpandingWindowSplitter(
        initial_window=36,  # 例如先用 3 年訓練
        step_length=3,      # 每次往前滾 3 個月
        fh=[1, 2, 3]        # 評估 1-3 個月 horizon
    )
    
    CV_scores = []
    for train_idx, test_idx in cv.split(y):
        y_train, y_test = y.iloc[train_idx], y.iloc[test_idx]
        X_train, X_test = X.iloc[train_idx], X.iloc[test_idx]
    
        forecaster.fit(y_train, X=X_train)
        y_pred = forecaster.predict(fh=cv.fh, X=X_test)
    
        score = mean_absolute_percentage_error(y_test, y_pred)
        CV_scores.append(score)
    
    print("CV MAPE:", sum(CV_scores) / len(CV_scores))
    

    這個流程可以放在一個 LLMBlueprintForecaster 類別裡,作為你的 AutoForecast 前端代理:

    1. 給資料描述與限制
    2. LLM 產生藍圖
    3. craft() 轉成 pipeline
    4. 用時間窗交叉驗證打分
    5. 挑最佳藍圖,固化成產線模型

    建議與注意事項

    1. LLM 亂組 class / 參數:一定要有 validator

    常見問題:

    • 寫出不存在的 class 名稱(如 XGBoostForecaster 明明沒這個)
    • 傳錯 參數名稱 或型別

    實務上建議:

    • 自行維護一份 白名單 registryALLOWED_ESTIMATORS, ALLOWED_TRANSFORMERS,包含合法 class 與參數 schema
    • LLM 輸出後先做 schema validation,不合法就直接丟棄或要求 LLM 修正

    2. 避免過度複雜 pipeline:限制深度與組合數

    LLM 很容易產生「看起來很專業」的 pipeline:一堆 transformer 疊來疊去,訓練時間爆炸還容易 overfit。

    做法:

    • 在 prompt 裡明寫:max_pipeline_depth、禁止嵌套某些昂貴 transformer
    • 在 validator 裡硬限制步數,例如 len(steps) <= 4
    • 將 fit time / memory 也當成 約束條件,訓練時加上 timeout + 監控

    3. 嚴格避免 leakage:時間切割一律「只看過去」

    坑點:

    • 把整段資料做標準化 / 滯後特徵時,無意間用到未來資訊

    避免方式:

    • 一律用 sktime 的 transformer + forecaster pipeline,讓 transform 在 fit 只看到 train window
    • cross-validation 必須用 ExpandingWindowSplitter / SlidingWindowSplitter 類型
    • 在 prompt 裡提醒:不得使用未來的統計量(例如整體均值)來處理訓練資料

    4. 在專案中落地:把 LLM 當 search policy,而不是 oracle

    建議實務流程:

    1. Search policy:LLM 只負責提案藍圖,不直接上產線
    2. 離線評估:用固定的 backtest 配置(split、metric、timeout)評估每個藍圖
    3. 固化最佳藍圖:將 blueprint JSON 連同該版本資料 schema 一起存入 repo
    4. CI 自動回歸
    5. 新資料 schema / 分布變化時,自動對舊藍圖重新訓練 + 打分
    6. 可以定期讓 LLM 在新 constraint 下重新產生藍圖,與舊版本對比
    7. 可重現性:所有 LLM 輸出(prompt + response)都要 versioning(例如存到 S3 / Git LFS),確保每個産線模型的來歷可追溯

    關鍵結論:

    • craft() + LLM = 可控的 AutoForecast 工具鏈,你掌控 search space 與評估邏輯
    • 把 LLM 當作「有經驗的建模同事」,而不是神諭;所有藍圖都要在 sktime 的嚴格回測與 CI 下過關,才能進產線

    這樣,在實際銷售 / 房地產等時間序列場景中,你可以以相對低成本,不斷迭代更好的預測流程,同時維持可重現與可維運的工程品質。


    🚀 你現在可以做的事

    • 在專案中安裝並載入 sktime,試著手動呼叫 craft() 建一個簡單 pipeline
    • 依照文中範例,實作一份包含 max_pipeline_depth 與白名單的 LLM prompt,讓 LLM 先產出一版 pipeline_spec
    • 為產出的 blueprint 加上 safe_craft() + 時間序列交叉驗證,建立一個最小可用的 LLMBlueprintForecaster 原型
  • NuExtract3:把 PDF 截圖變成乾淨資料

    NuExtract3:把 PDF 截圖變成乾淨資料

    📌 本文重點

    • NuExtract3 專門做「影像 / PDF → 結構化文字」
    • 直接輸出 JSON / Markdown,省掉後續清洗
    • 可自架本地部署,敏感資料不用上雲
    • 用 prompt 自訂欄位 schema,方便接到現有 workflow

    把亂七八糟的 PDF、發票截圖、表格照片,丟進 NuExtract3,就能直接拿到乾淨的 JSON / Markdown 結構化資料,方便你後續丟進 Notion、Google Sheet 或資料庫繼續用。

    官方開源介紹(含 Demo 連結):Reddit:NuExtract3 released


    核心功能:三件事講完 NuExtract3

    1. 多種文件型態,一次搞定

    NuExtract3 是基於 Qwen3.5-4B 訓練的開源多模態模型(Apache-2.0 授權),主打「影像 / PDF → 結構化文字」。實際可以拿來處理:

    • 多頁 PDF:報表、合約、研究報告
    • 發票、收據、報銷單:紙本拍照、掃描檔
    • 表格:Excel 匯出成 PDF、紙本表單的掃描
    • 表單截圖:Google Form 結果頁、線上後台報表截圖

    你只要準備:

    • 一個檔案(PDF / 圖片)
    • 一個「你想要的結構」描述(例如:請輸出成 JSON,欄位有 datevendortotal_amount

    就能讓它幫你把畫面裡的內容拉成乾淨結構。

    💡 關鍵: 只要定義好欄位結構,NuExtract3 就能把任何格式雜亂的文件,轉成統一結構的資料,後續處理成本會大幅下降。


    2. 直接輸出 JSON / Markdown,少一個清洗步驟

    NuExtract3 的設計重點不是「純 OCR」,而是「OCR + 結構化輸出」。實際測試時,你可以要求:

    • 輸出 JSON:適合丟進程式、API、資料庫
    • 輸出 Markdown:適合整理筆記、放進 Notion、Obsidian

    例如你給他一張發票照片,提示可以這樣寫:

    你是一個資料錄入助手。從這張發票中擷取欄位,並輸出 JSON:
    {
      "date": "發票日期 (YYYY-MM-DD)",
      "vendor": "商家名稱",
      "invoice_number": "發票號碼",
      "items": [
        {"name": "品項名稱", "quantity": 數量, "unit_price": 單價, "amount": 金額}
      ],
      "subtotal": 小計,
      "tax": 稅額,
      "total": 總金額
    }
    如果沒有某個欄位,填 null。
    

    輸出就會直接是可用的 JSON,不用再寫額外的字串處理把文字拆欄位。


    3. 本地部署,自已控管資料隱私

    NuExtract3 以「開源權重、自架」為主:

    • 模型權重可下載,Apache-2.0 授權,可商用
    • 可以在自己筆電、公司伺服器上跑
    • 不需要把發票、合約等敏感文件上傳到第三方雲端

    你可以先在官方 Hugging Face Space 線上試,用得順手再搬回本地。

    線上 Demo(免註冊):搜「NuExtract3」即可在 Hugging Face Spaces 上找到官方 Space。

    💡 關鍵: 在合約、財務等敏感場景,自架 + 開源授權讓你既能自動化,又不必冒資料外流風險。


    適合誰用:三個典型場景

    1. 財務 / 行政:發票、報銷單半自動錄入

    適用情境:

    • 同事每個月丟一堆發票照片、PDF 報銷單
    • 你要把日期、金額、商家、發票號碼一筆筆打進系統或 Excel

    可以這樣用:

    1. 把所有發票照片存進一個資料夾
    2. 用腳本逐張丟給 NuExtract3,要求輸出統一格式的 JSON
    3. 把 JSON 轉成 CSV,匯入到:
    4. 公司報銷系統
    5. Google Sheet 統計報表

    立即可做的行動
    – 把你現有的 2–3 張發票/收據,丟進官方 Space,測試能不能抓出你要的欄位(日期/金額/店名)。


    2. 自媒體 / 法務:整理掃描合約、條款重點

    適用情境:

    • 合作合約只有掃描版 PDF
    • 你只關心「合約雙方」「金額」「期限」「解約條件」「付款節點」

    你可以:

    1. 把 PDF 上傳 NuExtract3
    2. 用自然語言指定要的欄位,例如:
    請閱讀這份合約,並用 JSON 回答:
    {
      "party_a": "甲方名稱",
      "party_b": "乙方名稱",
      "contract_term": "合約期間(文字說明)",
      "payment_terms": "付款條件摘要",
      "termination_clause": "解約條款摘要"
    }
    
    1. 把輸出貼進 Notion,或丟給 ChatGPT / 其他 LLM 再做風險檢查

    立即可做的行動
    – 找一份你平常會反覆查的合約掃描檔,試著用 NuExtract3 生成「合約摘要 Markdown」,看可讀性如何。


    3. 數據分析師:報表、問卷結果結構化

    適用情境:

    • 手上有 PDF 報表、問卷紙本掃描
    • 想要的,是一張可以直接做分析的表格

    使用方式:

    1. 對著一頁表格截圖
    2. 提示要求輸出成「每列一筆紀錄」的 JSON 陣列
    把這頁問卷結果表格,轉成 JSON 陣列,每列是一位受訪者:
    [
      {
        "id": "編號",
        "age": 年齡,
        "gender": "性別",
        "q1": "問題1答案",
        "q2": "問題2答案"
      }
    ]
    
    1. 把 JSON 轉成 CSV 後丟進 Python / R / Excel 分析

    立即可做的行動
    – 拿一頁報表截圖,試著讓 NuExtract3 幫你還原成表格,再貼進 Google Sheet 看欄位是否正確。


    怎麼開始:五分鐘上手路線

    步驟 0:先線上玩一次(不用裝任何東西)

    1. 打開瀏覽器,前往 Hugging Face Space(搜尋 NuExtract3
    2. 上傳一張發票 / 合約 / 表格截圖
    3. 在「指令」欄位輸入你想要的輸出格式(JSON / Markdown + 欄位定義)
    4. 看輸出結果是否符合你平常的工作需求

    如果這步已經感覺能用,再考慮搬回本機或公司伺服器。

    💡 關鍵: 先用線上 Demo 驗證「欄位抓得準不準」,再投入時間做 Docker 與腳本整合,能避免白做工。


    步驟 1:在本機 / 伺服器用 Docker 跑起服務

    以下是假設官方提供 Docker 映像的典型流程(實際請以官方 README 為準):

    # 1. 拉取映像
    docker pull numind/nuextract3:latest
    
    # 2. 啟動服務(假設開在 8000 port)
    docker run -d \
      --gpus all \
      -p 8000:8000 \
      --name nuextract3 \
      numind/nuextract3:latest
    

    啟動後通常會有一個簡單 API,例如:

    curl -X POST http://localhost:8000/extract \
      -F "file=@invoice.jpg" \
      -F 'prompt=請擷取發票資訊並輸出 JSON,欄位:date, vendor, total_amount'
    

    回傳的就是 JSON 結果,可以直接被腳本處理。


    步驟 2:用簡單 Python Script 跑推論

    如果你偏好直接在 Python 裡呼叫(例如透過 vLLM / Transformers),典型流程會像這樣(範例示意):

    from PIL import Image
    import requests
    import json
    
    API_URL = "http://localhost:8000/extract"
    
    image_path = "./samples/invoice.jpg"
    prompt = "請從這張發票擷取日期(date)、商家(vendor)、總金額(total_amount),並輸出 JSON。"
    
    files = {"file": open(image_path, "rb")}
    data = {"prompt": prompt}
    
    resp = requests.post(API_URL, files=files, data=data)
    result = resp.json()
    
    print(json.dumps(result, ensure_ascii=False, indent=2))
    

    這段可以直接嵌入到你現有的報表處理、RPA 流程裡。


    步驟 3:自訂你的欄位 schema

    NuExtract3 沒有「固定欄位」,而是靠你的提示(prompt)決定要萃取什麼。實作時可以:

    1. 先在 Notion / Google Sheet 寫好你要的欄位列表,例如:
    2. date
    3. vendor
    4. category
    5. subtotal
    6. tax
    7. total
    8. 在提示裡把這些欄位寫成 JSON 模板,明確說明格式
    9. 要求:
    10. 用固定欄位名稱
    11. 金額用數字,不要加貨幣符號
    12. 缺失欄位填 null

    這樣輸出就更穩定,後續程式處理也比較不容易爆炸。


    步驟 4:組一個簡單 workflow:NuExtract3 + Google Sheet / Notion

    你可以很快做出一個「半自動錄入」流程:

    發票例子:

    1. 把所有發票照片放進 invoices/ 資料夾
    2. 用 Python 跑一個簡單批次處理:
    3. 逐張呼叫 NuExtract3 API
    4. 收集 JSON 結果
    5. 把 JSON 轉成 CSV:
    6. pandas 寫入 Google Sheet(透過 Google API)
    7. 或匯出 CSV 手動上傳

    概念範例:

    import os, json, requests, csv
    
    API_URL = "http://localhost:8000/extract"
    
    rows = []
    for fname in os.listdir("./invoices"):
      with open(os.path.join("./invoices", fname), "rb") as f:
        resp = requests.post(
          API_URL,
          files={"file": f},
          data={"prompt": "請輸出 JSON,欄位:date, vendor, total_amount"}
        )
      data = resp.json()
      rows.append([data["date"], data["vendor"], data["total_amount"]])
    
    with open("invoices.csv", "w", newline="", encoding="utf-8") as fp:
      writer = csv.writer(fp)
      writer.writerow(["date", "vendor", "total_amount"])
      writer.writerows(rows)
    

    Notion 的話,則可以用 Notion API 建立資料庫頁面,把每一筆 JSON 轉成一筆資料列。


    小結:什麼時候值得用 NuExtract3?

    • 你有大量掃描檔、截圖要轉成結構化資料
    • 內容多是表格、發票、收據、合約這類「格式固定但樣式雜」的文件
    • 你在意 資料不能丟到雲端,希望自架

    先在 Hugging Face Space 玩 10 分鐘,如果覺得可用,再花半天把 Docker + 簡單腳本接起來,你就多了一個專門幫你「把亂檔變乾淨資料」的本地工具。

    🚀 你現在可以做的事

    • 上 Hugging Face 搜尋 NuExtract3,用 2–3 張發票或表格截圖測試輸出 JSON / Markdown
    • 在 Notion 或 Google Sheet 列出你常用的欄位 schema,順手寫一個對應的 prompt 模板
    • 在本機用 Docker 跑起 nuextract3,照文中的 curl 或 Python 範例打一次 API,驗證能否接到現有流程
  • 把 NVIDIA Deep Research 當實習生用

    把 NVIDIA Deep Research 當實習生用

    📌 本文重點

    • NVIDIA Deep Research Agent 是「會自己調研與寫報告」的 AI 實習生
    • 能自動上網搜尋、整理來源並產出可追溯的研究報告
    • 以「專案工作空間」形式運作,適合市場研究與技術選型等場景

    用一句話講清楚:NVIDIA Deep Research Agent 就是「會自己上網查資料、存筆記、整理報告、附上引用來源」的 AI 實習生,比一般只能聊天的機器人,更接近一個真的研究助理。

    專案連結(GitHub):https://github.com/NVIDIA/GenerativeAIExamples/tree/main/agents/deep-research


    核心功能:比一般聊天機器人多了什麼?

    1. 會自己規劃調研流程,而不是只回一段答案

    一般聊天機器人:

    • 你問:「幫我看 2024 台灣電動車市場發展?」
    • 它直接生成一段「看起來合理」的摘要,但可能沒查新資料,來源不明。

    Deep Research Agent 的做法:

    1. 先把問題拆成子任務:市場規模、主要品牌、政策、關鍵數據…
    2. 逐步上網搜索,每一步都記錄查到的內容
    3. 整理成「研究筆記檔」,最後再寫成報告

    💡 關鍵: Deep Research 不是只回一段答案,而是走完整「拆題 → 搜尋 → 做筆記 → 成稿」流程。

    你可以做的事:

    • 在 prompt 裡直接下達研究任務,例如:
    • 「請做一份 5 頁的市場研究:主題是台灣 2024 電動車市場,列出主要品牌、市佔估計、最近一年重要新聞,最後整理成簡短建議。」
    • 把它當「會自己查資料的實習生」,而不是問答機器人。

    2. 自動搜尋 + 整理來源,幫你做「可追溯」的研究

    Deep Research Agent 會:

    • 主動呼叫搜尋工具(預設走網路 search API)
    • 讀取多個網站內容,過濾重複與雜訊
    • 把每條資訊連同來源網址存起來
    • 最後在報告中附上清楚引用(像研究報告的 reference 區)

    對比一般聊天機器人:

    • 回答多半是「綜合模型訓練時學到的知識」,很難知道哪一段是最新、哪一段來自哪個來源。

    💡 關鍵: 每個關鍵結論都對應具體網址,讓你可以抽查與追溯,而不是盲目信任模型輸出。

    你可以做的事:

    • 要求它在輸出中固定附上引用區,例如:
    • 「請在每個關鍵結論後標注 [來源 1] [來源 2],並在文末列出完整網址。」
    • 用這些引用,手動抽查 1–2 個關鍵數據,確保內容可信。

    延伸閱讀:NVIDIA 開源介紹文章(Towards AI)
    https://pub.towardsai.net/nvidia-open-sourced-a-deep-research-agent-that-beat-openai-on-its-own-benchmarks-5339b3f547fb


    3. 有「工作空間」的 Agent,而不是沒記憶的聊天框

    很多非程式碼 Agent 做不好,很大原因是沒有穩定工作空間——這點在 Reddit 討論裡講得很清楚:non-coding agents should also live in file systems

    Deep Research Agent 的設計比較像一個「專案資料夾」:

    • 每個研究任務會形成一組檔案:
    • 原始搜尋結果
    • 中途整理的筆記
    • 最終報告
    • Agent 可以反覆讀寫這些檔案,再繼續深化研究

    💡 關鍵: 用「檔案與專案」當記憶體,讓 Agent 可以多輪迭代深化同一主題,而不是每次從零開始聊。

    你可以做的事:

    • 把每一個「問它的大問題」當成一個專案,例如:
    • project: EV-market-tw-2024
    • project: crm-tools-comparison
    • 把產出的 Markdown 報告直接丟進你的筆記軟體(Obsidian、Notion)當專案檔案。

    適合誰用?幾個實際場景

    1. 市場研究 / 會前簡報

    需求:你要開一場客戶會議,得先快速了解對方產業現況。

    操作示例:

    • 任務描述:
    • 「客戶是做 B2B SaaS CRM 的,幫我整理 2022–2024 全球 B2B CRM 市場趨勢、主要玩家、常見商業模式,最後整理一句話電梯簡報 + 5 項我應該問的問題。」
    • 把 Deep Research Agent 的報告:
    • 直接 copy 成 PowerPoint 大綱
    • 或貼到 Notion,當成會前 brief

    2. 競品分析 / 工具選型

    需求:你在選 CRM、客服系統、A/B test 平台。

    操作示例:

    • 任務描述:
    • 「幫我比較 Intercom、Zendesk、Freshdesk 三個工具,重點看價格方案、支援語言、整合 API 能力,做成表格,最後給出 3 種不同規模公司(10 人、50 人、200 人)的建議。」
    • 你要做的:
    • 把輸出的表格貼進你團隊的提案文件
    • 把引用網址交給實習生或同事做二次驗證

    3. 技術選型調研

    需求:你在選擇 LLM、RAG 架構或 MCP agent 框架要上線到產品(可參考這篇實戰文:https://pub.towardsai.net/i-shipped-a-rag-mcp-agent-to-production-five-things-broke-0f030ff6f3f9)。

    操作示例:

    • 任務描述:
    • 「整理目前主流的 RAG + MCP agent 開源方案,要求列出:GitHub 星數、是否支援雲端 / 本地部署、常見踩坑與評估建議,重點對象是要上 production 的 SaaS 團隊。」
    • 接著你可以:
    • 用報告當作技術評估會議的初稿
    • 在每個風險點上再請 Deep Research Agent 深挖,反覆迭代。

    怎麼開始:從安裝到接上你的知識庫

    1. 準備環境與 API Key

    最低需求:

    • Python 3.10+ 環境(本機或雲端都可)
    • 一張 NVIDIA GPU 會更順(但也可只用雲端 API)
    • 至少一個可用的 LLM API Key,例如:
    • NVIDIA NIM / NVIDIA API
    • 或其他支援的雲端模型供應商

    你要做的事:

    1. 申請 NVIDIA API 帳號(若使用他們的模型):https://build.nvidia.com
    2. 拿到 API Key,寫入 .env 或環境變數,例如:

    bash
    export NVIDIA_API_KEY="你的 key"


    2. 安裝與在本機快速跑起來

    以 GitHub 專案為主線:

    git clone https://github.com/NVIDIA/GenerativeAIExamples.git
    cd GenerativeAIExamples/agents/deep-research
    
    # 建議開一個虛擬環境
    python -m venv .venv
    source .venv/bin/activate  # Windows 用 .venv\Scripts\activate
    
    pip install -r requirements.txt
    

    通常範例專案會提供一個 demo 指令(名稱可能略有變化,依 README 為準):

    python deep_research.py \
      --query "請分析台灣 2024 電動車市場的主要趨勢與廠商" \
      --output ./outputs/ev-market-tw-2024.md
    

    你要做的事:

    • 改掉 --query 裡的內容,直接換成你現在真正在做的專案題目
    • 執行後,到 outputs/ 夾裡打開 Markdown 報告

    3. 在雲端(Colab / VS Code Remote)跑

    如果你本機沒有 GPU 或懶得裝環境,可以:

    • 找一份針對 NVIDIA Deep Research Agent 的 Colab notebook(通常社群會有人整理)
    • 或在雲端 VM(如 AWS、GCP、Azure)裡跑上述安裝流程

    你要做的事:

    • 儲存好 notebook,當成你的「研究模板」
    • 每次只改問題與輸出檔名,就能重複使用。

    4. 串接到你的筆記 / 知識庫工作流

    目標:建立一條「從問題 → 調研 → 報告」的固定管線。

    最簡單做法:

    1. 輸出格式固定用 Markdown
    2. 在啟動腳本中加入:--format markdown(若有此選項)
    3. 指定輸出資料夾對應到筆記工具
    4. Obsidian:把 outputs/ 變成一個 vault 內的資料夾
    5. Notion:用 Notion API 定期把 outputs/*.md 同步上去
    6. 在筆記裡建立「研究模版」
    7. 標題:{{專案名稱}} Deep Research 報告
    8. 區塊:背景、發現、數據表、風險、建議、來源連結

    你可以立刻做的事:

    • 為你接下來一週要決定的「一個重要選項」(例如要不要換 CRM)建一個專案資料夾
    • 用 Deep Research Agent 生成第一版調研報告
    • 用你自己的專業重新整理重點後,發給團隊當決策前閱讀材料。

    小結:把它當「會查資料的實習生」,而不是魔法

    使用 NVIDIA Deep Research Agent 的正確心態:

    • 它擅長的是幫你大量收集與初步整理,節省你 60–80% 搜集資料的時間
    • 你仍然要:
    • 選題、定義問題
    • 抽查關鍵引用
    • 把輸出整理成真正要對外發表的報告或簡報

    💡 關鍵: 把 60–80% 搜資料的時間交給 Agent,你可以把精力放在判斷與決策上。

    只要先從一個你本來就要做的調研開始,你很快就會感受到,把 AI 當實習生用,和「只是多一個聊天機器人」有多大差別。

    🚀 你現在可以做的事

    • 打開 GitHub 專案並依照 README 完成安裝,跑一次示範指令
    • 挑一個你這週真的要做的決策議題,寫成 --query 給 Deep Research Agent
    • 把產出的第一版報告整理進 Obsidian 或 Notion,當作團隊會議前閱讀材料
  • ClickUp 裁員,其實是在排練新公司形態

    ClickUp 裁員,其實是在排練新公司形態

    📌 本文重點

    • AI 正在從「工具」變成可編制的「員工單位」
    • 成本結構轉為「人力+雲端」綁在一起,治理風險倍增
    • 能管理 AI 的人與組織,將主導下一輪權力重分配

    第一個敢公開說「用數千個 AI 代理換掉數百名員工」的,不只是 ClickUp,而是整個軟體業的真心話被說出口。這不是一次孤立的裁員,而是「AI 員工作為產品類別」成形的標誌事件,預演的是未來公司裡:老闆是人,幹活的是 AI,人類只剩少數「指揮官」。真正要被升級的,不是員工的服從度,而是企業對 AI 治理、審計與責任 的認知。


    一、從「工具」到「員工」:AI 正在變成一個清楚的「編制」選項

    在 TechCrunch 的報導裡,ClickUp 這家九年的協作軟體新創,選擇用「數千個 AI agents 替代數百名員工」。這句話的關鍵不只在於比率,而在於說法:不是用 AI 功能提升效率,而是直接用 AI 當「員工單位」

    💡 關鍵: 從「提升效率的工具」到「可編制的員工單位」,代表 AI 已正式成為組織設計中的人力替代選項。

    對照 Reddit 上那篇整理「AI employees / digital workers / AI teammates」的討論,可以看到一個清晰的產品地圖:

    • AI SDR、AI 客服、AI 招聘、AI 會計、法遵代理、工程/SRE 代理、安全分析、醫療行政
    • 它們不是「大模型 API」,而是被包裝成一個可購買的「職缺」:買一年,就等於請一名(或一隊)數位員工

    也就是說,企業在做組織設計時,開始有三種選項:

    1. 正職員工(薪資+保險+辦公成本)
    2. 外包/顧問(按專案計費)
    3. AI 員工/代理人(按席位、按任務或按 Token 計價)

    ClickUp 的選擇,是把第 1 類大幅削減,直接擴大第 3 類。這件事一旦被證明在財報上「說得過去」,就會變成一種新標準:

    「為什麼這個職能還是人,不是 AI 員工?」

    這跟 2010s 的雲端轉型很像:當年問題是「為什麼還要自己養機房?」;未來問題會變成「為什麼還要自己養這麼多人?」


    二、「裁員+代理」= 新版雲端+外包,但有三個關鍵差異

    表面上,這波 AI 代理潮很像 2010 年代的 雲端化+外包潮

    • 企業把機房搬上 AWS / GCP,砍掉 IT 基礎設施團隊
    • 業務支援、客服與部分開發工作外包到成本更低的地區

    但這一次有三個本質差異:

    1. AI 不是「交給別人」,而是「交給沒人格的東西」

    外包還是人,你可以簽約、要求加班、追究責任;AI 代理沒有勞動契約、沒有加班費,也沒有「人格責任」,只有 服務條款模型提供商的 SLA

    結果是:

    • 責任鏈從「員工 → 部門主管 → 公司」
    • 變成「模型提供商 → 平台 → 使用公司」,勞動責任變成產品責任,監管邏輯完全不同

    2. 成本結構從「固定開支」變成「變動雲帳單」,壓力更直接

    Uber COO Andrew Macdonald 已經公開說,越來越難為某些 「tokenmaxxing」式的 AI 開銷辯護──就是那種為了「最強大模型」瘋狂燒推論成本、卻說不清 ROI 的專案。

    Wix 的案例更直接:

    • 核心業務仍成長,Q1 營收 YoY +14%、Bookings +15%
    • 同時是史上最大裁員:砍掉約 800–1000 人,占 20% 員工
    • 主因是:收購 Base44、自建模型、推論成本與行銷費,把利潤吃光

    💡 關鍵: 即便營收還在成長,若 AI 成本與收購壓縮利潤,企業仍會用大規模裁員修正成本結構。

    2010s 的雲端潮,其實是「CapEx 換成 OpEx」;AI 代理潮則是「人力成本+雲端成本纏在一起」,變成一張每月浮動的 GPU 帳單。沒算清楚,很快就會走上 Uber/Wix 的抱怨路線:效率沒明顯起來,但雲帳單每天在燒現金

    3. 自動化不再只砍「藍領流程」,而是砍進白領決策鏈

    上一波自動化,多數是對準工廠、倉儲、客服前線;這一波的 AI 員工,直接瞄準的是:

    • SDR、行銷投放、合約審閱、會計對帳、報表編撰、程式碼維護

    換句話說,這次被自動化的,是「辦公室裡的你」。而 ClickUp 的作法,把這件事做得非常明牌:

    不是「幫你省時間」,而是「把你換掉」。


    三、誰會先被替代?誰反而能靠 AI 擴張?

    1. 風險排序:先砍「流程型白領」,再動「問題定義者」

    從目前 AI 員工產品圖譜來看,最危險的族群有三類:

    1. 高度標準化、以文書為主的白領
    2. 如客服、基礎 HR、低階會計、標準合約審核、KYC/AML 初審
    3. 特徵:輸入結構清楚、輸出有模板、指標明確好衡量
    4. 流程導向的初階工程與維運
    5. Bug triage、簡單 ticket 處理、重複性 refactor、監控報警初步分析
    6. 越是「照 Runbook 就能做完」的工作,越容易被 AI SRE / AI Developer 接手
    7. 只會「操作工具」、不會定義問題的中階職位
    8. 例如只會把客戶需求變成 Jira 任務、把會議紀錄抄進 Confluence 的「資訊中繼站」

    相對安全的,是那些:

    • 能定義 KPI、設計流程,甚至能為 AI 員工訂出「工作說明書」的人
    • 能在錯誤情境裡,跨部門協調、承擔對外責任的人

    簡單講:能管理 AI 的人,暫時比被 AI 管的人安全。

    2. 中小企業:不是被吃掉,而是第一次有「自帶外包團隊」的機會

    另一邊,對 中小企業與中小銀行 這種資源有限的組織,AI 代理反而是一種擴張槓桿。

    以文章 〈Agentic AI and the SMB Banking Advantage〉 的觀察為例:

    • 78% 的中小銀行 已導入 SaaS 核心銀行平台
    • 到 2026 年,SaaS/託管模式預計占核心銀行市場 約 2/3

    💡 關鍵: 流程已被 SaaS 標準化的產業,中小玩家可以率先用 AI 代理獲得「類大企業級」自動化能力。

    這些 SaaS 系統本身就把流程「標準化、結構化」,再疊上 agentic AI,就變成:

    • 中小銀行可以用 AI 代理人跑合規檢查、風險評估、客服
    • 不必自建巨大的 IT / 風控團隊,卻能達到類似大行的自動化水準

    同樣邏輯放大到所有中小企業:

    有 SaaS、流程清楚的小公司,會比「什麼都自己客製」的大公司,更快接上 AI 代理編排。

    真正會被吃掉的,是沒有把流程標準化、又同時失去人力與人才的中型組織:人不夠多做事、系統又亂到 AI 無法接手。


    四、勞動法規與監管:AI 雇主 vs 人類員工,新戰場在哪?

    ClickUp 這種「用 AI 代理取代員工」的動作,遲早會逼監管機構回答幾個具體問題:

    1. 集體裁員+大量導入 AI,有沒有新的通報與評估義務?
    2. 現有的勞動法規只看人頭數,不看「AI 取代比例」
    3. 未來很可能會要求:大規模自動化前,要做影響評估、職訓計畫或補償機制

    4. AI 員工犯錯,算誰的過失?

    5. 錯誤放貸、歧視性篩選履歷、錯殺帳號,責任在使用公司?模型供應商?還是 SaaS 平台?
    6. 監管趨勢會逼出一套 「AI 風險分攤」條款與審計標準

    7. AI 代理的「行為紀錄」要如何保存與稽核?

    8. 若 AI 自動下單、調整價格、拒絕客戶,日後爭議時要查看哪一層 log?
    9. 這會催生 AI 審計工具、語義治理平台、Agent 行為 Replay 系統 的新市場

    換句話說:

    未來的勞檢,不只查加班單,還要查 AI 代理的 Decision Log。

    真正有前瞻性的公司,不會等監管來,而是先把 AI 治理、審計與責任分工 內建到技術與流程裡。


    結論:現在該做的,不是抱怨 AI,而是重寫你的「職位說明書」

    ClickUp 不是特例,而是企業開始把自己當成「AI 雇主」的第一聲槍。在這個新博弈裡,你如果只是希望「不要被 AI 換掉」,基本上已經輸了一半。

    對不同角色,我的具體建議是:

    • 工程師與白領
    • 立刻開始練習:用 AI 代理完成一個完整業務流程,而不是只用 ChatGPT 改句子
    • 把自己變成「AI 團隊領班」:會設計流程、定 KPI、寫 prompt-runbook、看 log、調整策略
    • 中小企業與團隊主管
    • 先做兩件事:標準化流程+選對 SaaS 平台,再談導入 AI 代理
    • 把 AI 席位當成「人頭」管理:計算單位產出、錯誤率、監控成本,而不是只看「有沒有用上最強模型」
    • 企業決策者與法務
    • 立即建立最小可行的 AI 治理框架:權責矩陣、審計 log、模型供應商合約中的責任條款
    • 把「AI 員工」當成一個新的法律風險來源,而不是單純的 IT 成本項目

    這一波浪潮裡,真正需要被升級的,不是員工的服從度,而是企業對 AI 治理與責任的成熟度。能及早把 AI 當成「要管理的員工」,而不是「炫耀的功能」的組織,才有資格在下一輪裁員名單之外,寫下別人的未來。

    🚀 你現在可以做的事

    • 寫一份「AI 代理職位說明書」,設計一個你工作中可由 AI 接手的完整流程
    • 盤點團隊目前使用的 SaaS,標記出哪些流程最適合先導入 AI 代理
    • 與法務或管理層討論,草擬一版簡單的 AI 治理框架與 Decision Log 留存規範
  • Claude 私有化:自托管沙箱與 MCP 隧道實戰

    Claude 私有化:自托管沙箱與 MCP 隧道實戰

    📌 本文重點

    • 模型與編排托管在 Anthropic,工具與資料留在你 VPC
    • 透過 self‑hosted sandbox 把程式執行權收回內網
    • 用 MCP tunnel 只開安全出站連線打通內網工具
    • 權限設計與審計要靠嚴格的 tools schema 與網路邊界

    典型企業場景:你想讓 Claude Managed Agent 幫你跑 CI/CD、讀內網 Git、打內部 REST / Postgres API,但 不能開公網入站、不能把 Git 暴露出去。這次的 self‑hosted sandboxes + MCP tunnels 更新,基本上就是:

    模型與編排留在 Anthropic,工具執行與資料存取拉回你自己的 VPC,且只用安全出站連線。

    實務上等於多了一種選擇:不用把模型拉進內網自建 inference,也能在嚴格邊界內讓 Agent 控制 CI、讀 repo、查 DB。


    重點說明:架構與安全邊界怎麼畫

    1. Orchestrator vs Tools:誰在外面、誰在裡面?

    Claude Managed Agents 大致拆成兩層:

    1. Orchestrator(Anthropic 端托管)
    2. 理解使用者意圖、規劃步驟、決定要叫哪些工具。
    3. 透過 MCP 協定 呼叫你定義的 tools(MCP server)。

    4. Tools / MCP servers(你自己控制)

    5. 例如:git、CI/CD runner、Postgres、內部 REST API
    6. 可以跑在 self‑hosted sandbox 裡(受控容器/VM),或直接在你內網 VPC。

    💡 關鍵: Orchestrator 永遠只看得到你暴露出的 MCP tools 與其 I/O,真正的 Git / DB 資料面與執行權都留在你 VPC。

    關鍵:Orchestrator 看不到你的 Git/DB,只能透過你暴露出的 MCP tools 操作,權限由你決定。


    2. MCP 協定與 server:最小必須心智模型

    MCP server 就是一個會講 JSON‑RPC over stdio / WebSocket 的後端,向 Agent 宣告自己有哪些工具。概念類似「強 typing 的 function calling」。

    一個簡化版的 MCP server schema(YAML)可能長這樣:

    name: corp-dev-tools
    version: 0.1.0
    
    tools:
      - name: git_read_file
        description: 讀取內部 Git repo 某個檔案內容
        input_schema:
          type: object
          required: [repo, path, ref]
          properties:
            repo: { type: string }
            path: { type: string }
            ref:  { type: string }
    
      - name: ci_trigger_pipeline
        description: 觸發 CI pipeline,只能在 allowlist 專案上執行
        input_schema:
          type: object
          required: [project, branch]
          properties:
            project: { type: string }
            branch:  { type: string }
    

    Agent 端會看到 明確的工具清單與參數結構,再決定何時呼叫。


    3. Self‑hosted sandbox:把「程式執行權」留在自己這邊

    self‑hosted sandbox 解決的是:「我不想讓 Anthropic 直接在他們 infra 上跑 shell / Python,請改在我 VPC 裡跑」。

    實作上可以是:

    • 一個專用 k8s namespaceFargate / VM,跑 Anthropic 提供的 sandbox runtime。
    • Agent 要執行程式碼(例如跑單元測試、lint、git 操作),會透過安全通道把 code / 指令丟到這個 sandbox。

    典型邊界設計:

    • sandbox 只能出站連到:
    • 你的 Git / CI / DB / 內部 API
    • Anthropic 的 MCP tunnel endpoint
    • 不能直連其他敏感系統(或至少預設 deny)。

    實際好處: Agent 可以幫你跑 pytest、打 CI webhook、改 Git branch,
    但所有「可以執行程式碼的環境」都在你的控制下,方便做防火牆、資安掃描、審計。


    4. MCP tunnels:如何在不開洞的情況下連到內網

    MCP tunnel 解決:「我的 MCP server 在 VPC 裡,如何讓 Anthropic 托管的 Agent 打到它,但我不願意開入站 443?」

    典型拓撲:

    [Anthropic Orchestrator]
            ^
            | (MCP over tunnel)
            v
    [MCP Tunnel Client in VPC] ----> [MCP Server + Sandbox]
              (outbound TLS)
    

    關鍵特性:

    • 只有 VPC → Anthropic 的出站連線(類似反向隧道)。
    • 隧道建立後,Anthropic 端像是在打本地 MCP server,但實際流量是經由你建立的 mutual TLS / token 隧道轉回來。
    • 容易套用零信任思路:每條隧道都視為一個 identity,綁定最小權限的一組 tools。

    💡 關鍵: 只用出站隧道與 mTLS,就能在不開任何入站 port 的前提下,把內網工具安全地接給 Managed Agent 用。


    實作範例:VPC 內最小可行架構

    場景:

    • VPC 內:
    • 一台 MCP server + sandbox Pod/VM。
    • 連得上 GitLab、Postgres、內部 https://api.intra
    • 出站:允許打到 Anthropic 的 MCP tunnel endpoint

    1. MCP server:Git + Postgres + REST API

    以 Node.js 為例(pseudo‑code):

    import { MCPServer } from "@anthropic-ai/mcp-sdk";
    import { execSync } from "node:child_process";
    import { Client } from "pg";
    import fetch from "node-fetch";
    
    const gitAllowlist = ["service-a", "service-b"];
    
    const server = new MCPServer({ name: "corp-dev-tools" });
    
    server.tool("git_read_file", async ({ repo, path, ref }) => {
      if (!gitAllowlist.includes(repo)) {
        throw new Error("repo not allowed");
      }
      const base = "/srv/git/" + repo;
      const content = execSync(`git --git-dir=${base} show ${ref}:${path}`, {
        encoding: "utf8",
      });
      return { content };
    });
    
    server.tool("db_read_customer", async ({ id }) => {
      const client = new Client({
        host: process.env.PG_HOST,
        user: "readonly_agent",
        password: process.env.PG_PWD,
        database: "app",
        ssl: true,
      });
      await client.connect();
      const res = await client.query("SELECT id, name, status FROM customers WHERE id=$1", [id]);
      await client.end();
      return { rows: res.rows };
    });
    
    server.tool("call_internal_api", async ({ path, method, body }) => {
      if (!path.startsWith("/public-agent/") || method !== "POST") {
        throw new Error("not allowed");
      }
      const resp = await fetch(`https://api.intra${path}`, {
        method,
        headers: { "Authorization": `Bearer ${process.env.AGENT_TOKEN}` },
        body: JSON.stringify(body ?? {}),
      });
      const json = await resp.json();
      return { status: resp.status, data: json };
    });
    
    server.listen();
    

    重點:

    • gitAllowlist:避免 Agent 任意讀所有 repo。
    • Postgres 使用 readonly_agent 帳號,限制只讀特定 schema。
    • 內部 API 降到 /public-agent/ 子路徑 + 專用 token。

    2. MCP tunnel client:出站連上 Anthropic

    實際指令會以官方 CLI / container 為主,概念配置類似:

    anthropic-mcp-tunnel \
      --mcp-url=http://localhost:8000 \
      --agent-id=corp-ci-agent \
      --tls-cert=/etc/mcp/cert.pem \
      --tls-key=/etc/mcp/key.pem \
      --anthropic-endpoint=https://mcp-tunnel.anthropic.com \
      --tags=env:prod,scope:ci
    

    在 Anthropic 控制台,你會:

    • 建立一個 Managed Agent:corp-ci-agent
    • 只綁定這條 tunnel 曝露的 corp-dev-tools MCP server。
    • 開啟前人工審閱 / 部分工具 auto‑approve(視風險)。

    3. ACL 與工具權限設計

    簡單的 policy‑as‑code 思路:

    agent: corp-ci-agent
    allowed_tools:
      - git_read_file
      - ci_trigger_pipeline
      - db_read_customer
      - call_internal_api
    
    constraints:
      git_read_file:
        repos: ["service-a", "service-b"]
        max_file_size_kb: 256
    
      db_read_customer:
        max_rows: 1
    
      call_internal_api:
        allowed_paths:
          - "/public-agent/deploy"
          - "/public-agent/status"
    

    你可以在 MCP server 裡讀這個 YAML,做額外校驗。不要把 ACL 寫死在 prompt 裡,防禦提示注入要靠程式碼與網路邊界。


    建議與注意事項:安全坑與實務整合

    1. 工具權限過大 = Agent RCE 風險

    OWASP Agent Top 10 已經把 工具濫用 / 權限濫用 列為前幾名風險。常見錯誤:

    • 一個 tool 可以執行任意 shell、對任何 DB 下任意 query。
    • Agent 可以打到整個內網,而不是只打 CI / Git / API Gateway。

    建議:

    • 一個 tool 做一件小事,強 schema,避免 free‑form SQL / shell。
    • DB 使用 只讀 + row‑level / column‑level policy
    • 網路上用 安全群組 / SG 把 sandbox 能打的 IP 段鎖死。

    2. 審計 / Logging:要記「自然語言意圖 + 工具調用」

    很多企業只有 infra log,缺少「Agent 為什麼要做這件事」的上下文。

    建議最低標準:

    • 針對每次工具呼叫記錄:
    • user_id / session_id
    • Agent 看到的 自然語言任務描述(可脫敏)
    • 工具名稱 + input 參數(敏感欄位做 partial redaction)
    • 執行結果摘要 / status code

    這樣在事後對齊 OWASP 事件分析時,才能把「提示注入 → 工具濫用 → 資料外洩」串成一條 timeline。


    3. 網路與認證:守住 MCP 隧道與 secrets

    重點:把隧道視為一個高價值通道,跟 VPN 一樣認真看待。

    具體建議:

    • 隧道一律走 mTLS,cert 由內部 CA 或雲端 CA 管理。
    • 隧道 client 的 API token / cert 放在 Vault / KMS,sandbox 上只拿短期 lease。
    • 工具裡 不要回傳 secrets(例如整個 JWT 與 DB 密碼)到 Agent,必要時只在 server 端使用。
    • 若擔心 API key 滲透,在 sandbox 層加 egress proxy,對外送出的 HTTP header 做檢查 / scrub。

    4. 與 SOAR/服務目錄/Secrets 管理整合的實務問題

    實務上會遇到:

    • SOAR / ticket 系統
    • 建議把「開 ticket / 查告警 / 執行 playbook」封裝成 MCP tools,權限沿用既有 RBAC。

    • 服務目錄(例如 Backstage)

    • MCP tools 可以讀服務目錄 API,讓 Agent 知道 repo 屬於哪個團隊、能不能改 config。

    • Secrets 管理(Vault/KMS)

    • 不要給 Agent 直接讀 Vault 的能力;改由 MCP tool 在 server 端解密,對 Agent 只暴露結果(或再加工)。

    5. 和「模型拉進內網自建 inference」的取捨

    Managed Agent + self‑hosted sandbox + MCP tunnel:

    • 優點:
    • 不用自己跑 LLM cluster,只負責工具、網路、權限
    • 快速接雲端最新模型(含之後像 Mythos 這種安全模型的企業版)。
    • 合規上:資料只經由 tools 進出,你可以精準監控。

    • 缺點:

    • Orchestrator 還是在 Anthropic,那邊仍會看到 工具 I/O 摘要
    • 對極端資料主權(完全不能出域)的場景不適合。

    自建 inference:

    • 優點:
    • 完整掌控模型與權限,所有 token 在你網段內。

    • 缺點:

    • 要自己做 Agent orchestration、tooling、guardrail、OWASP Top 10 風險防護。
    • 成本與維運門檻高。

    如果你目前已在雲上、允許「模型在外、資料在內」,這次的 Claude Managed Agents 私有化能力 是一個相對平衡的折衷:

    把最麻煩的 LLM 與 Agent orchestration 交給 Anthropic,把最敏感的程式執行與資料權限留在 VPC,用 MCP + sandbox 畫清楚邊界。

    🚀 你現在可以做的事

    • 在現有 VPC 內起一個簡單 corp-dev-tools MCP server(照文中 Node.js 範例改成你公司的 Git / DB / API)
    • 部署 anthropic-mcp-tunnel 類似的隧道 client,實測只用出站連線即可讓 Managed Agent 操作內網工具
    • 寫一份 YAML ACL(如文中 policy‑as‑code 範例),把 repo / DB / API 權限具體收斂後再開放給 Agent 使用
  • RTK 終端機 AI 助手:少花 90% Token

    RTK 終端機 AI 助手:少花 90% Token

    📌 本文重點

    • RTK 用結構化壓縮幫你減少重複丟給模型的 Token
    • 常用專案可重用上下文,問越多次平均越省
    • 在終端開發流程中無痛接入,五分鐘內可上手

    你現在用 AI 幫忙寫程式,很可能有一大半錢都燒在「重複丟給模型看的 Token」上,而 RTK 要做的,就是在終端機幫你把這些多餘 Token 全部擠乾。

    專案連結:https://github.com/rtk-ai/rtk


    核心功能:RTK 怎麼幫你少丟 Token?

    1. Prompt 壓縮:把廢話變成精簡結構

    一般你在終端機複製錯誤訊息、整段程式碼給 AI,看起來沒幾行,實際 Token 超多。RTK 做的事是:

    • 先在本地做「結構化」:分出錯誤訊息、檔案片段、指令上下文
    • 用短 Prompt 模板描述需求,例如:
    • 錯誤訊息 + 詢問目標(幫我找 bug)
    • 這段程式 + 修改要求(改成 async)
    • 最後送給模型的內容會是高度壓縮的結構,而不是你手動貼的一大坨文字

    你可以這樣行動:

    • 不要再打長篇自然語言 Prompt,改用 RTK 的命令別名(例如 rtk fix, rtk explain),把「要做什麼」交給 RTK 的模板處理。

    2. 上下文重用:同一個專案不重講第二次

    平常你每問一次 AI:「這個專案是做什麼的?」「這個模組是幹嘛?」都在重複付費。RTK 會:

    • 對常問的目標(例如某個目錄、特定檔案)做一次「結構化摘要」
    • 接下來跟同一個會話相關的指令,就重用這些摘要,而不是把整份檔案再丟一次

    具體效果:

    • 問同一個 repo 的問題越多次,平均每次的 Token 消耗越低
    • 對超過數萬行的專案,差異會特別明顯

    💡 關鍵: 專案越大、問越多次,RTK 的上下文重用機制帶來的平均 Token 成本下降就越明顯。

    你可以這樣行動:

    • 針對常用專案建立一個 RTK 會話,之後都在這個會話裡問問題,而不是每次都「一次性丟完所有檔案」。

    3. 結構化輸入 / 輸出:減少「看懂答案」的成本

    RTK 不只壓縮你給模型的內容,也會讓模型的回答更結構化,例如:

    • 要求模型輸出固定格式:原因 / 修復步驟 / 建議指令,而不是亂聊一通
    • 要模型只返回「要改的那幾行」,而不是整份檔案,減少輸出 Token

    你可以這樣行動:

    • 習慣用 RTK 指令,而不是「請用條列式說明」這種自然語言;RTK 已經替你定義好能省 Token 又好讀的輸出格式。

    RTK 當 CLI 代理:三種高頻使用場景

    1. 日常開發:錯誤訊息、修小段程式、產生命令

    在日常開發中,你大概會一直做這幾件事:

    1. 看錯誤訊息:不知道哪裡爆
    2. 改小段程式:加 log、改型別、改函式簽名
    3. 產生命令:不知道某個工具的 CLI 參數要怎麼下

    RTK 的典型玩法:

    • 看錯誤訊息

    bash
    # 把上一個命令的錯誤訊息丟給 RTK 解釋
    some-command-that-fails 2>error.log
    rtk explain-error < error.log

    行動:把原本你會貼到 ChatGPT / Claude 的 error log,改成用 rtk explain-error,RTK 會用短 Prompt + 結構化提問幫你省 Token。

    • 改小段程式

    bash
    # 針對某個檔案的一小段範圍做修改建議
    rtk edit src/main.rs --range 20-60 --ask "改成 async/await 風格,保留原本邏輯"

    行動:只給 RTK「相關的幾十行」,不要整支檔案,RTK 會幫你把上下文描述給模型,降低 Token。

    • 產生命令

    bash
    # 根據需求生成 shell 指令,不用自己翻 man page
    rtk cmd "把 logs 資料夾裡 7 天前的 .log 壓成一個 tar.gz,檔名帶日期"

    行動:用自然語言描述「你想做什麼」,讓 RTK 負責用精簡 Prompt 跟模型談,輸出最終的 shell 指令。


    2. 讀專案:總結檔案、生成說明、快速問代碼

    當你接手一個新 repo,通常會做:

    • 看 README 還是不懂整體架構
    • 想知道某個模組的職責
    • 想快速問「這個函式在哪裡用到」

    RTK 的用法可以是:

    • 總結檔案 / 目錄

    “`bash
    # 總結一個檔案在幹嘛
    rtk summarize src/lib.rs

    # 總結一個目錄的主要模組與職責
    rtk summarize src/handlers/
    “`

    • 生成說明文件

    bash
    # 幫某個模組產生說明文字(例如供 PR 或文件用)
    rtk doc src/services/user.rs --format markdown

    • 快速問代碼

    bash
    # 在 repo 裡問問題,RTK 只會選關聯檔案給模型看
    rtk ask "登入流程中,token 驗證主要在哪幾個檔案處理?"

    行動:把「整個 repo 丟進 AI」改成「用 rtk summarizertk ask 針對性查詢」,每次只給必要檔案,Token 消耗會明顯下降。


    3. 結合 tmux / fzf / git workflow:變成隨叫隨用 AI 幫手

    RTK 的本質是單一 CLI binary,很適合跟你現有的終端機工具整合:

    • 搭配 tmux:固定一個 pane 做 RTK 聊天視窗

    bash
    # tmux 裡開一個新 pane 專門跑 rtk chat
    rtk chat

    行動:在 tmux 裡維持一個長期會話,RTK 可以反覆重用上下文,越聊越省 Token。

    • 搭配 fzf:選檔後丟給 RTK

    bash
    # 用 fzf 選一個檔案丟給 RTK 總結
    rtk summarize "$(fzf)"

    • 搭配 git workflow:讓 AI 看 diff 而不是整檔

    bash
    # 只把當前變更的 diff 丟給 RTK 請他協助寫 PR 說明
    git diff > /tmp/diff.patch
    rtk explain-diff < /tmp/diff.patch

    行動:在你的 shell 設定(例如 .zshrc.bashrc)裡建立幾個 alias,把平常會複製貼上的工作改用 RTK 處理:

    alias rpr="git diff | rtk explain-diff"
    alias rerr="rtk explain-error"
    

    適合誰用?三種典型開發者

    • 1. 每天都開著 AI 編輯器(Cursor、Claude Code)的工程師
      你已經習慣「寫一寫就問 AI」,RTK 適合接在你終端機工作流的空白處:看 log、看 diff、產生命令,這些在編輯器之外的操作用 RTK 承接,Token 花在真正需要的地方。

    • 2. 維護大型專案或多 repo 的開發者
      尤其是 Rust / Java / monorepo,檔案多、型別長、錯誤訊息又臭又長,用 RTK 的結構化摘要 + 上下文重用,可以顯著減少「每次都要把半個專案丟給 AI」的情況。

    • 3. 自費用 API Key 的個人開發者 / Side project 作者
      如果你是自己刷卡買 OpenAI / Anthropic / 其他 LLM Token,用 RTK 是直接對帳單有感的程度;原本一個月 30–50 美金的,也許可以壓到 10–20 美金。

    💡 關鍵: 若你自己付模型費,用 RTK 把「貼錯誤 / 貼整檔 / 貼 diff」改成結構化對話,帳單級別的節省會非常直接。


    5 分鐘開始用 RTK:安裝、設定、跑幾個指令

    1. 安裝單一 binary

    到 GitHub Releases 頁下載對應平台的 binary:

    • 進入 https://github.com/rtk-ai/rtk
    • 點選右側 Releases
    • 下載對應系統檔案(例如 rtk-x86_64-unknown-linux-gnurtk-aarch64-apple-darwin
    • 賦予執行權限並放到 PATH 裡,例如:
    chmod +x rtk-x86_64-unknown-linux-gnu
    sudo mv rtk-x86_64-unknown-linux-gnu /usr/local/bin/rtk
    

    2. 設定 API Key

    RTK 本身不附模型,你需要設定自己的 LLM 供應商 API key(例如 OpenAI / Anthropic 等,依官方文件為準):

    export OPENAI_API_KEY="你的 key"
    # 或依照 RTK 說明設定 RTK 專用環境變數,例如:
    export RTK_MODEL_PROVIDER=openai
    export RTK_MODEL=gpt-4.1-mini
    

    建議:

    • 選一個便宜的小模型當預設(例如 gpt-4.x-mini / o3-mini 類型),RTK 本身就已經會幫你省 Token,小模型更划算。

    💡 關鍵:RTK_MODEL 設成較便宜的小模型,再搭配 Prompt 壓縮,能在不明顯犧牲效果的前提下把成本再壓一截。


    3. 試跑幾個典型指令

    照著下面三步走,你大概五分鐘內就能感受到 RTK 的節奏:

    1. 解讀錯誤訊息

    bash
    cargo build 2>error.log
    rtk explain-error < error.log

    1. 總結專案主檔案

    bash
    rtk summarize src/main.rs

    1. 生成一個命令

    bash
    rtk cmd "找出今天修改過的 .rs 檔,列出檔名和變更行數"


    怎麼量化:你到底省了多少 Token?

    如果你是自己付費買 API,建議直接用「帳單」來感受 RTK 的效果,而不是只看官方說的 60–90%。你可以:

    1. 先觀察一週的原始用量
    2. 不改工作流程,照常用 Cursor / Claude Code / ChatGPT 開發
    3. 記下這週在模型供應商後台的 Token 用量 / 金額

    4. 下一週加上 RTK

    5. 日常 terminal 問題全部改用 RTK(錯誤、log、diff、命令)
    6. 大型專案閱讀改用 rtk summarizertk ask

    7. 對比兩週帳單

    8. 如果你平常大量貼錯誤訊息、整檔 code、diff 給 AI,看起來會有 30–50% 甚至更多的節省

    進階做法:

    • 把 RTK 指令加上 --verbose 或開啟 debug log(依官方說明),讓它輸出實際的 Token 用量,對照供應商後台的數字,清楚看到壓縮前後的差異。

    RTK 的重點不是「多一個聊天機器人」,而是把你原本就會做的事——貼錯誤、貼代碼、貼 diff 問 AI——改成一種對 Token 比較友善的方式。如果你現在已經很依賴 AI 寫程式,那麼把這些對話搬進 RTK,大概是最省時、也最省錢的下一步。

    🚀 你現在可以做的事

    • 進入 RTK GitHub Releases 下載對應平台的 rtk binary 並加入 PATH
    • 在 shell 設定中加入 OPENAI_API_KEYRTK_MODEL 等環境變數,設好預設小模型
    • 建立幾個常用 alias(例如 rerr, rpr),並用 rtk explain-errorrtk summarize 開始取代貼到聊天機器人的動作
  • 用 Claude.md 做一個不會爛掉的長跑代理

    用 Claude.md 做一個不會爛掉的長跑代理

    📌 本文重點

    • CLAUDE.md 嚴格約束代理行為,避免長跑爛掉
    • 核心原則是「行動+證據」,禁止空談與無限迴圈
    • 透過上下文壓力自查與簡潔憲法,讓代理長時間穩定運作

    用一份不到 100 行的 CLAUDE.md,就能讓你的 Claude 代理連跑幾小時都不會開始胡言亂語、卡住不動或重複修同一個 bug。

    參考原作者在 Reddit 的分享:
    – 長跑 Claude Code 代理的設定檔開源文:https://www.reddit.com/r/ClaudeAI/comments/1tjy3sk/i_opensourced_the_operating_file_that_keeps_my/
    – 100 條個人 AI 代理實戰心得:https://www.reddit.com/r/ClaudeAI/comments/1thi6nh/100_tips_tricks_for_building_your_own_personal_ai/


    核心功能:這份 CLAUDE.md 到底做了什麼?

    1. 只允許「行動與證據」,禁止長篇空談

    長跑代理會爛掉,通常是這三個症狀:

    1. 開始寫「我將會…」「接下來我要…」但不真的執行工具
    2. 一直說「應該已修好」但沒有測試結果
    3. 花很多篇幅重複解釋計畫,實際變更很少

    CLAUDE.md 的核心規則,就是把這些行為全部關掉:

    • 輸出只允許三種型態
    • 已完成的動作(例如:檔案修改、指令執行、API 呼叫)
    • 具體問題 / 需要決策的提問
    • 極短的進度摘要
    • 聲稱「完成」前要附證據:如測試輸出、報表截圖路徑、命令列結果

    💡 關鍵: 將輸出限制為「行動+證據」,能大幅減少長篇空談與無效迴圈,讓長跑代理真正持續推進任務

    你可以做的事
    – 在你的專案根目錄放一份 CLAUDE.md,明確寫出:
    – 「不要描述你要做什麼,只要直接做並回報結果」
    – 「任何『應該已修好』前,必須貼出測試輸出」

    2. 內建「上下文壓力」自我檢查

    長跑幾小時後,對話上下文會變超長,Claude 開始:

    • 忘記早期需求
    • 無法把握目前專案狀態
    • 回答變模糊或重覆

    原作者在 CLAUDE.md 裡加了一條關鍵原則:

    代理要定期自查上下文壓力:發現自己搞不清狀態,就主動整理摘要、刪除多餘上下文、或要求人類幫它重設現狀。

    具體做法通常包含:

    • 每完成一個階段任務,就輸出一個「短摘要 + 關鍵檔案清單」
    • 長度過大時,優先保留:
    • 最新的決策
    • 目前版本的檔案 / 結構
    • 尚未完成的待辦

    你可以做的事
    – 在 CLAUDE.md 寫明:
    – 「當你感覺自己不確定目前狀態時,先輸出一份 10 行內的現況摘要,再繼續工作。」
    – 「如需要,可要求人類提供『目前唯一真實狀態』說明,並用這份說明覆蓋舊假設。」

    3. 任務憲法:不靠「一長串 Prompt」,靠幾條簡潔原則

    多數人用代理會寫一大段 prompt,結果 Claude 讀不完、也記不住。CLAUDE.md 的思路是:

    • 用 10–20 條簡短規則,定義這個代理的「憲法」
    • 每條都要能對應到實際行為約束,例如:
    • 「若有工具可以做某事,優先用工具,不要手寫模擬輸出」
    • 「對同一錯誤連續嘗試 3 次仍失敗,就停下來請人類決策,不要無限迴圈」

    💡 關鍵: 把 10–20 條行為規則寫成固定「憲法」,比灌輸一大段單次 prompt 更能在長跑中維持穩定行為

    參考 Reddit 另一篇實戰文:https://www.reddit.com/r/ClaudeAI/comments/1thi6nh/100_tips_tricks_for_building_your_own_personal_ai/

    你可以做的事
    – 先列出你的代理最常「爛掉」的 3 個行為,逐條寫進 CLAUDE.md,用「禁止 / 應改為」的格式:
    – 「禁止:連續兩次貼出幾乎相同的錯誤訊息。應改為:第二次失敗時,整理你已試過的方法,請人類選下一步。」


    適合誰用:3 個實戰場景

    1. 單機腳本型代理:排程任務、批次資料處理

    你有這些需求時,很適合:

    • 每晚跑一次報表轉檔腳本
    • 每週整理一批 CSV / Excel 檔,把欄位標準化
    • 定期爬某個網站的資料、存到本地或資料庫

    做法:

    1. 用 Claude Code 或本地腳本,讓代理可以:
    2. 讀寫特定資料夾
    3. 執行 shell 指令(或以 PowerShell / bash 包一層)
    4. CLAUDE.md 放在專案根目錄,寫清楚:
    5. 允許改動哪些檔案
    6. 批次任務完成的判定方式(例如輸出檔案數量、檔名規則)
    7. 用排程工具觸發:
    8. macOS / Linux:cron 或 systemd timer
    9. Windows:排程工作排程器 + 命令列啟動代理腳本

    2. 長連線開發代理:Claude Code / VS Code / Cursor 類工作流

    如果你常用 Claude 來寫程式、改大型專案,長時間開著一個 session,很容易出現:

    • 忘記三小時前的設計決定
    • 重複修同一支檔案
    • 一直在講解架構,但實際 commit 很少

    這時 CLAUDE.md 非常好用:

    實際操作:

    1. 在 VS Code 專案根目錄新增 CLAUDE.md,內容包含:
    2. 專案簡述
    3. 允許的工具(例如:跑測試、執行 npm testpytest 等)
    4. 「行動 > 敘述」與「證據 > 猜測」等規則
    5. 在 Claude Code / Cursor 內重新開啟專案,確保代理會讀到這個檔案
    6. 開發時明確下指令:
    7. 「請遵守 CLAUDE.md,連續工作直到完成以下任務…」
    8. 「每完成一個子任務,產出最多 5 行的進度摘要」

    進階:也可以搭配多代理流程,參考:https://www.reddit.com/r/ClaudeAI/comments/1thi16y/how_i_built_a_9agent_team_where_my_agents/

    3. 自建小型自動化服務:抓報表、清理資料

    你想做一些「半自動」小工具,例如:

    • 每週自動登入內部系統下載報表
    • 讀取資料夾裡的新檔案,做資料清洗 / 格式標準化
    • 根據最新資料,產出簡短摘要寄 Email

    可用的整合方式:

    • MCP / shell 指令
    • 透過 Model Context Protocol 暴露一組工具給 Claude,例如:
      • list_files, read_file, run_command
    • 規則寫進 CLAUDE.md

      • 「處理檔案時,一律用工具列出檔名,不要從記憶猜」
    • Power Automate

    • 由 Power Automate 排程觸發 HTTP / CLI,呼叫你的 Claude 代理後端
    • 回傳的結果可再串 Outlook 寄信、寫入 Excel、更新 SharePoint

    你可以做的事
    – 先選一個最小自動化任務,例如「每週整理銷售報表」,只把這一個流程寫入 CLAUDE.md,確保跑穩,再慢慢加其他任務。


    10 分鐘上手:從 fork 到跑起你自己的代理

    以下是一條「10 分鐘內能動起來」的最短路徑,你可以依你使用的工具微調。

    Step 1:fork 開源專案

    1. 前往 Reddit 原文查看作者提供的 repo(通常會在貼文內):https://www.reddit.com/r/ClaudeAI/comments/1tjy3sk/i_opensourced_the_operating_file_that_keeps_my/
    2. 在 GitHub 上 fork 到自己的帳號
    3. 本地 git clone 下來

    Step 2:複製 CLAUDE.md 到你的專案

    1. 打開作者的 CLAUDE.md,通讀一遍規則
    2. 複製到你自己的專案根目錄
    3. 只做三種修改:
    4. 把專案描述改成你的任務(例如:財報整理、數據清洗、網站爬蟲)
    5. 調整允許使用的工具(例如是否允許 rm / 刪檔)
    6. 加上 2–3 條你最在意的「不准爛掉」條款

    💡 關鍵: 只動專案描述、工具白名單與 2–3 條關鍵禁令,能在 10 分鐘內把通用 CLAUDE.md 變成專屬代理憲法

    Step 3:綁定你常用的工作環境

    依你用的平台選一條:

    • Claude Code / VS Code / Cursor
    • 在這個專案資料夾內開啟編輯器
    • 確認工具(跑測試、shell、檔案操作)已啟用
    • 對 Claude 說:「請讀 CLAUDE.md 並照裡面的規則長時間工作」

    • MCP + shell 指令

    • 建立一個 MCP server,提供 run_shell, read_file, write_file 等工具
    • CLAUDE.md 明確寫出「所有系統操作一律經由 MCP 工具」
    • 用你偏好的前端(例如自寫 CLI、簡單 Web)呼叫 Claude

    • Power Automate / 其他自動化

    • 建一個小型後端服務(可用 Python FastAPI / Node.js)包住 Claude API
    • 後端每次呼叫 Claude 時,都把專案檔案+CLAUDE.md 帶入 context
    • 用 Power Automate 定期觸發這個 API

    Step 4:跑一個「能觀察的」任務,調整規則

    1. 選一個 30–60 分鐘的任務給代理連續跑(例如重構某一個資料夾的程式碼)
    2. 觀察:
    3. 什麼時候開始廢話變多?
    4. 哪種情況會卡在同一個錯誤?
    5. 直接把這些「失敗模式」寫回 CLAUDE.md 變成新條款

    重複兩三輪,你會得到一份專屬於你工作流、而且真的能「長跑不爛」的代理憲法。


    小結:先管好行為,再管工具

    長跑 AI 代理很容易越跑越爛,通常問題不在模型,而在缺乏清楚的行為規則。透過一份設計良好的 CLAUDE.md

    • 把輸出限制在「行動+證據」
    • 讓代理主動監控上下文壓力
    • 用幾條簡單原則當作「憲法」

    你可以在單機腳本、開發環境、多工具自動化裡,得到一個穩定得多的 Claude 代理。

    建議從今天開始:先為你最常用的一個專案寫一份 CLAUDE.md,跑一個完整任務,看看它能連續跑多久還保持專注。那會是你感受到「長跑代理真的可用」的第一步。

    🚀 你現在可以做的事

    • 在一個常用專案根目錄新建 CLAUDE.md,寫入「行動+證據」與上下文自查規則後實際跑一次長任務
    • 從 Reddit 原文 fork 作者 repo,閱讀並複製其中 CLAUDE.md,依你的工作流做 2–3 處客製調整
    • 列出你代理常見的 3 個「爛掉模式」,逐條轉寫成禁止條款加進 CLAUDE.md,並在下一次工作中觀察效果