標籤: Gemini 3.5

  • 用 Gemini 3.5 控螢幕:Agent 實戰架構解析

    用 Gemini 3.5 控螢幕:Agent 實戰架構解析

    📌 本文重點

    • Gemini 3.5 直接「看螢幕 + 點 UI」,大幅簡化自動化 Agent
    • 用 DSL 約束操作與多輪回饋,提升穩定性與錯誤恢復能力
    • 安全邊界與權限治理是避免變成「超級巨鼠標」的關鍵

    Gemini 3.5 的 Computer Use 功能直接解決了一個老問題:過去我們寫辦公自動化或 E2E 測試 Agent,必須在「語言模型」和「操作工具」之間做大量 glue code(PlaywrightSelenium、各種 RPA SDK)。現在模型本身就能看螢幕 + 理解 UI + 產生操作事件,實作「會自己點 UI」的 Agent 架構可以大幅簡化,同時在 OSWorld 這類 benchmarks 上已經能接近人類級別的操作能力。

    💡 關鍵: Gemini 3.5 直接讀螢幕與 DOM,讓原本需要大量 glue code 的自動化流程被模型本身吸收,工程複雜度大幅下降。


    重點說明:Gemini 控螢幕的技術斷面

    1. 螢幕感知:Screenshot + DOM 雙通道

    Gemini 3.5 FlashComputer Use 能力裡,核心是讓模型同時看到:

    • 螢幕截圖:提供視覺語意,例如按鈕風格、顏色、位置、Tooltip 等。
    • DOM 或可操作節點樹:提供結構語意,如 aria-labelroleid、階層關係。

    實作上通常會有一個中介層:

    • 你的 Agent Runtime 負責抓取 當前視窗 screenshot、序列化 DOM / widget tree 成結構化 JSON
    • 透過 Gemini API 以多模態輸入丟給模型,模型回傳抽象操作意圖(例如「點選『匯出報表』按鈕」),再轉成具體事件(例如 click(x, y)click(selector))。

    這比傳統 RPA 的「座標點擊」穩健得多,因為模型能根據文字與結構定位元素,不再怕視窗尺寸微調就全掛。

    2. 操作語義到事件映射:從自然語言到 GUI 事件模型

    Gemini 本身不直接產生 OS-level 事件,而是給出操作語義,由你的 Agent 層做事件映射。典型設計是:

    • 模型輸出一組高階指令
    • click element: 「匯出報表」scroll until: 「三月」type in field: 「搜尋」 -> "季報"

    • Agent 將其轉換成具體事件:

    • 瀏覽器端:document.querySelector(...) + element.click()
    • 桌面端:座標點擊(OS API / robot library)

    建議在系統層設計一個 操作 DSL,例如:

    {
      "actions": [
        { "type": "click", "target": { "text": "匯出報表", "role": "button" } },
        { "type": "fill", "target": { "placeholder": "搜尋" }, "value": "季報" },
        { "type": "wait", "condition": { "text": "匯出完成" }, "timeoutMs": 10000 }
      ]
    }
    

    讓 Gemini 的輸出約束在這個 DSL 內,再由你寫 resolverDSL 轉成實際 API 呼叫,如 PlaywrightChromium DevTools 或自製桌面自動化套件。

    3. 權限與安全沙箱:避免做成「超級巨鼠標」

    能「看螢幕 + 點 UI」的 Agent,在安全上本質上是半個遠端操控工具。要避免直接變成超級巨鼠標,需要在設計時就加上:

    • Scope 限制:只允許控制特定應用(例如公司內部 CRM),而不是整個 OS
    • 權限分級:讀取螢幕 ≠ 可以操作所有按鈕,對「刪除」「匯出」「設定」類操作加上額外人為確認。
    • 審計與可回溯:所有操作都要有 log,包括模型輸入、輸出 DSL、最後映射的實際事件。

    Gemini 在雲端側有基本的安全保護,但真正壓力在你自家的 Agent Runtime。核心結論:螢幕控制能力是一把雙面刃,沒安全邊界就等同開放一個高權限自動點擊器。

    💡 關鍵: 把控制範圍鎖在特定應用與低權限環境,是避免「一個 Bug 變成全系統災難」的第一道防線。


    實作範例:會自己點 UI 的辦公自動化 / E2E Agent

    以下用 pseudo-code 示範一個基於 Gemini Computer Use 的 Agent 架構,對比你現在用 PlaywrightRPA 的做法。

    1. Agent 主循環:狀態管理與事件模型

    假設你有一個 Browser Automation Runtime,可以:

    • 抓取 screenshot
    • dump DOMJSON
    • 執行 DSL 動作

    初始化與一次任務呼叫

    # 假設有 gemini_client 已封裝好
    from agent_runtime import get_screenshot, get_dom_tree, execute_actions
    
    SYSTEM_PROMPT = """
    你是一個辦公自動化 Agent。你只能透過提供的 action DSL 操作螢幕。
    目標:根據使用者需求,在瀏覽器完成操作。
    請只輸出 JSON,不要輸出其他文字。
    """
    
    state = {
        "task": "下載最新的月報表並存到桌面",
        "history": []
    }
    
    def run_step(state):
        screenshot = get_screenshot()
        dom = get_dom_tree()  # 結構化 JSON
    
        prompt = {
            "system": SYSTEM_PROMPT,
            "user": {
                "task": state["task"],
                "history": state["history"],
                "screen": screenshot,   # 圖像
                "dom": dom              # 結構化文字
            }
        }
    
        # 透過 Gemini 3.5 Flash 多模態 API
        resp = gemini_client.generate(
            model="gemini-3.5-flash-computer-use",
            input=prompt,
            # 關鍵參數:讓模型遵守 DSL
            tools=[{"name": "ui_action_dsl", "schema": ACTION_SCHEMA}],
            temperature=0.2
        )
    
        actions = resp["actions"]
        result = execute_actions(actions)
    
        state["history"].append({"actions": actions, "result": result})
        return state
    
    # 任務循環(直到模型判斷完成)
    while not state.get("done"):
        state = run_step(state)
    

    關鍵設計點:

    • 使用 多步迭代:每次看最新螢幕 & DOM,再決定下一步 action,類似人類操作流程。
    • 將狀態(history)回饋給模型,讓它能做錯誤恢復與路徑修正。

    2. DSL Schema:限制模型輸出空間

    JSON Schema 方式提供 ui_action_dsl 給 Gemini(伺服器側 Stub 示意):

    export const ACTION_SCHEMA = {
      type: "object",
      properties: {
        actions: {
          type: "array",
          items: {
            type: "object",
            properties: {
              type: { enum: ["click", "fill", "scroll", "wait", "assert"] },
              target: {
                type: "object",
                properties: {
                  text: { type: "string" },
                  role: { type: "string" },
                  selector: { type: "string" },
                  ariaLabel: { type: "string" }
                }
              },
              value: { type: "string" },
              condition: { type: "object" },
              timeoutMs: { type: "number" }
            },
            required: ["type", "target"]
          }
        }
      },
      required: ["actions"]
    };
    

    把這個 schema 當作 tool 定義丟給 Gemini,模型就會傾向輸出符合 schemaJSON,而不是隨意產生指令文字。這比讓模型自己「猜 Playwright API」更穩。

    3. 錯誤恢復策略:從 E2E 測試角度看

    E2E 測試模式下,你可以:

    • 每個 step 後檢查 result 是否有錯誤(DOM element 找不到、timeout 等)。
    • 把錯誤詳細資訊(包含「按鈕找不到」等)回餵給模型,再跑下一個 step,讓 Agent 自己嘗試調整操作策略。

    示意:

    result = execute_actions(actions)
    if result.error:
        state["history"].append({"actions": actions, "error": result.error})
    else:
        state["history"].append({"actions": actions, "ok": True})
    

    這種「模型 + 真實環境回饋」的迭代,比傳統 Playwright 寫死 selector 更有韌性:UI 調整、小改版時,Agent 仍可能靠語意找到正確控件。

    💡 關鍵: 把錯誤結果當成下一輪輸入的一部分,能讓 Agent 自我修正,比單純重試同一段 script 聰明得多。


    建議與注意事項:和 RPA / Playwright 對比,以及安全邊界

    與傳統 RPA / Playwright 的優缺點對比

    優勢:

    • 選擇器韌性更高:不是全靠 #idxpath,模型會綜合文字、位置、上下文理解「這顆按鈕是做什麼的」。
    • 對自然語言任務友善:「幫我下載三月月報表」這種任務,不需要你事先拆成多條 script,Agent 自己規劃路徑。
    • 多模態容錯:螢幕上即使有動態廣告、複雜排版,模型也能分辨主要內容與干擾。

    劣勢 / 需要評估的點:

    • 成本與延遲:每一個 step 都要 call 一次 LLM,比傳統 script 直接執行慢且貴,適合複雜流程,不適合同一動作高頻批量執行。
    • 可預期性Playwright script 是 deterministic;Gemini Agent 則有一定隨機性(雖然可降低 temperature),需要監控與回滾機制。

    真實專案的安全與治理建議

    1. 明確劃定控制範圍

    2. 用獨立瀏覽器容器(例如專用 Chrome profileWebView),讓 Agent 只能看到業務系統,而非整個桌面。

    3. 對不同任務配置不同權限 profile,例如「只讀報表」「允許建立草稿但不可送出」。

    4. 強制人機協同節點

    5. 對敏感操作(刪除資料、匯出大量客戶名單)設計「人工確認」步驟,讓 Agent 停在「準備送出」頁面,由人點最後一個按鈕。

    6. 使用 UI 上的明確標記(例如「需管理員確認」)讓模型也知道哪些步驟不應自動完成。

    7. 完整審計 log + 可回放

    8. 記錄:模型輸入(螢幕縮圖、DOM 摘要)、模型輸出 DSL、實際執行的事件與結果。

    9. 可選擇在安全事件發生時回放整個操作過程,做事後分析。

    10. 避免敏感資料洩露

    11. screenshot 做遮罩(mask),例如遮蓋客戶姓名、金額等,再送給模型。

    12. DOM 摘要可做字段裁剪,只提供必要欄位(如 label、角色、結構),不要直接把完整表格資料送到雲端。

    13. 從小範圍 PoC 起步

    14. 先在「測試環境 + 低權限帳號」上跑 Agent,驗證行為穩定,再逐步提升權限。

    15. 與現有 Playwright / RPA 共存:把 Gemini Agent 用在「探索性操作」與「易變 UI」,穩定的核心流程仍用傳統 script

    總結:Gemini 3.5 的螢幕感知與控制能力,讓我們可以用更少的硬編碼 selector 和流程腳本,實作能「看得懂 UI、自己點按鈕」的辦公自動化 / E2E Agent。真正的工程重點在於:設計好操作 DSL、狀態管理與錯誤恢復機制,並在安全邊界、審計與人機協同上做好防護,讓這個 Agent 是可控的助理,而不是失控的超級巨鼠標。

    🚀 你現在可以做的事

    • 在你現有的 Playwright / Selenium 專案中,先為 1 個流程試做一個 ui_action_dsl,讓 LLM 產生 JSON 再轉成實際指令
    • 建一個測試用瀏覽器容器(低權限帳號 + 測試環境),接上 Gemini 3.5 Flash 多模態 API 做小型 PoC
    • 為預計自動化的系統列出敏感操作,先設計好「人工確認」與操作 log / 回放機制
  • NotebookLM 大升級:把 Gemini 變成你的研究員

    NotebookLM 大升級:把 Gemini 變成你的研究員

    📌 本文重點

    • NotebookLM 把閱讀、整理、寫程式整合在同一工作空間
    • 內建雲端 sandbox,可直接跑 Python 做資料分析
    • 透過 Agent 自動查網路資料,像一位會 Google 的研究員

    用一句話說 NotebookLM:把你的文件、網頁跟程式碼交給一個會自己查資料、寫筆記、跑程式的 AI 研究員,幫你把「看資料 + 做筆記 + 寫程式」整合在同一個工作空間。

    官方介紹與註冊入口:https://notebooklm.google.com
    相關報導:The Decoder(連結)、The Verge(連結


    核心功能:現在的 NotebookLM 到底多了什麼?

    1. Gemini 3.5:回覆更準、少亂講

    這次 NotebookLM 底層模型換成 Gemini 3.5 Flash,重點不是名字,而是實際效果:

    • 引用來源更清楚:問問題時,NotebookLM 會標記是從哪一份 PDF、哪一頁、哪一段抓出來的。
    • 和你自己的資料對齊:它只會優先根據你匯入的檔案回答,而不是憑空編故事。
    • 支援多文件綜合:你可以丟 10 篇論文、3 份簡報,直接問「幫我整理共同結論」。

    💡 關鍵: NotebookLM 會優先根據你匯入的資料回答問題,大幅降低「亂講」和憑空編造內容的風險。

    你可以怎麼用:

    • 把課程講義、公司簡報、研究論文丟進一個 Notebook,直接問:
    • 「請用 300 字整理這些文件的重點,分成三個小節。」
    • 「列出文件裡提到的所有關鍵術語,做成小抄。」

    2. 內建雲端 sandbox:直接在 Notebook 裡跑程式

    根據 The Decoder 報導,NotebookLM 現在有自己的 雲端電腦環境,可以:

    • 執行 Python / 程式碼片段,不用本機安裝任何東西。
    • 讓 AI 自己寫程式、執行、看結果,再調整程式碼。
    • 做資料分析:匯入 CSV、跑統計、畫圖,全在瀏覽器裡完成。

    💡 關鍵: 內建雲端 sandbox 讓你不用開 Jupyter 或設定環境,就能在瀏覽器裡完成程式與資料分析工作。

    你可以怎麼用:

    • 上傳一份 CSV 報表,在對話框輸入:
    • 「幫我用 Python 讀取這個檔案,算出每個產品線的月營收,並畫出折線圖。」
    • 有一段不熟悉的程式碼,直接貼進 Notebook:
    • 「解釋這段程式在做什麼,幫我加上註解,並用更易懂的寫法重構。」

    NotebookLM 會在它的雲端 sandbox 裡跑程式,再把結果和程式碼一起貼給你。

    3. Agent 式自動查資料:會自己 Google 的研究員

    新版 NotebookLM 加入了 Agent 式研究能力

    • 可以直接叫它「去幫我找資料」,它會透過 Google 搜尋 找來源。
    • 不用一開始就匯入檔案,也能從「空白」開始一個研究計畫。
    • 它會把找到的網頁、PDF 當成新的資料來源,整理成摘要或報告。

    The Verge 指出,現在你可以直接在 NotebookLM 裡啟動研究,而不是先手動找資料再貼進來。

    你可以怎麼用:

    • 問:
    • 「請幫我找三篇 2023 年後關於 LLM 應用在教育的研究,整理出研究問題、方法、結論。」
    • 要求:
    • 「所有引用請附上原始連結,最後用一段話提醒我這些研究的限制。」

    適合誰用:三個具體場景

    1. 學生:整理課堂講義與論文

    常見痛點:

    • 上課講義 + 教科書 + 老師 PDF + 論文,多到爆炸,很難整理成考前筆記。
    • 讀英文論文速度慢,抓不到重點。

    NotebookLM 的用法:

    1. 建立一個 Notebook,例如「機器學習期末」。
    2. 匯入:課程講義 PDF、指定閱讀論文、老師提供的投影片。
    3. 問:
    4. 「請用中文整理這份 Notebook 的期末考重點,照章節分類。」
    5. 「幫我做一份 10 題選擇題,題目來自這些文件,並給出解析。」
    6. 「這篇論文的實驗設計和 limitation 是什麼?用口語說明。」

    可立即採取的行動:

    • 把這學期最頭痛的一門課資料丟進 NotebookLM,直接讓它幫你做考前總整理。

    2. 產品經理:整理競品資料與市場研究

    常見痛點:

    • 競品官網、新聞稿、使用條款、App 介紹分散各處。
    • 每次開會都在重做一樣的「功能比較表」。

    NotebookLM 的用法:

    1. 新建 Notebook:「2024 Q3 競品研究」。
    2. 匯入:競品官網截圖 PDF、功能說明文件、先前做過的簡報。
    3. 啟用 Agent 查資料:
    4. 「幫我搜尋 3 家同類型 SaaS 產品的定價頁面,整理成表格。」
    5. 再問:
    6. 「針對我們現有產品,列出 5 個值得抄的功能點,並附上來源連結。」

    可立即採取的行動:

    • 建立你的「競品知識庫 Notebook」,每天丟一兩個新連結進去,讓 NotebookLM 幫你維護最新的競品視圖。

    3. 工程師:技術備忘錄 + 資料分析助手

    常見痛點:

    • 專案文件分散在 Confluence、Google Docs、GitHub Wiki。
    • 每次查舊專案架構或業務規則,都要重看一堆文件。
    • 做小型資料分析還得開 Jupyter、整理環境。

    NotebookLM 的用法:

    1. 建立 Notebook:「後端服務 A 技術文件」。
    2. 匯入:設計文件 PDF、API spec、README、部分程式碼片段。
    3. 提問:
    4. 「這個服務的主要資料表有哪些?幫我畫一個簡化的 ER 圖描述文字。」
    5. 「從這份 API 文件裡,整理一份給新同事看的 onboarding 指南。」
    6. 把日常 log / CSV 丟進去:
    7. 「用 Python 幫我分析這份 log,找出錯誤頻率最高的三個 endpoint,畫 bar chart。」

    可立即採取的行動:

    • 先選一個你最常被問的專案,把所有設計文件丟進 NotebookLM,之後把新同事導向 NotebookLM 問問題。

    怎麼開始:10 分鐘完成第一個 Notebook 專案

    步驟 1:開啟 NotebookLM

    1. 用 Chrome 或任一瀏覽器開啟:https://notebooklm.google.com
    2. 用你的 Google 帳號登入。
    3. 若地區未開放,可以先用 VPN 嘗試(注意公司政策)。

    步驟 2:建立第一本 Notebook

    1. 點選「New notebook」。
    2. 幫它取一個明確的名字,例如:
    3. 「行銷簡報整理」
    4. 「碩士論文文獻庫」
    5. 按「Add sources」,開始匯入資料。

    步驟 3:匯入 PDF / Docs / 網頁

    NotebookLM 支援:

    • 上傳 PDF、TXT、部分 Office 檔。
    • 直接選 Google Docs、Slides、Sheets。
    • 貼上網址,讓它自己抓取網頁內容(官網、部落格、新聞稿)。

    建議:先匯入 3–5 份你最近真的會用到的文件,不要一次丟 50 份,方便你先熟悉操作。

    💡 關鍵: 一開始只匯入 3–5 份核心文件,比一次丟 50 份更容易看出 NotebookLM 的效果並建立使用習慣。

    步驟 4:試用這 3 個 Prompt 模板

    以下是你可以直接複製貼上的實戰模板:

    模板 1:快速總整理

    你是一位擅長教學的筆記整理員。請根據這本 Notebook 內所有來源資料,整理一份 800 字以內的重點摘要,
    1. 先列出 5 個最重要的概念
    2. 每個概念用不超過 3 句話說明
    3. 最後用一段話提醒我考試或簡報時最容易忽略的地方

    模板 2:給不同對象的說明稿

    根據 Notebook 內的資料,分別寫兩版說明:
    1. 給完全沒有背景的新手,限制 300 字,盡量口語化
    2. 給同領域專業人士,限制 300 字,可以使用專業術語
    每一版都請標註引用的來源文件與頁碼(若有)。

    模板 3:資料 + 程式分析

    我上傳了一份 CSV 檔案,請你:
    1. 先用 Python 讀取資料並描述欄位
    2. 幫我算出各類別的平均值與標準差
    3. 畫出一張適合的圖表(你自己決定類型),並解釋為什麼這樣比較好讀
    請貼出完整的 Python 程式碼與分析結論。


    結語:把 NotebookLM 當成「專案專屬研究員」

    使用 NotebookLM 最重要的觀念是:為每個專案建一本 Notebook,讓它跟著專案一起長大

    • 學生:每門課一冊,所有講義與筆記都放進去。
    • 產品經理:每個產品線或競品一冊,讓它幫你維護最新情資。
    • 工程師:每個系統或專案一冊,變成活的技術備忘錄 + 分析環境。

    你只需要準備好資料,NotebookLM 會幫你查、幫你寫、幫你跑程式,真正變成「專案專屬的 Gemini 研究員」。

    🚀 你現在可以做的事

    • 登入 NotebookLM,為你目前最重要的專案建立第一本 Notebook
    • 先匯入 3–5 份你最近真的會用到的文件,實測上文提供的 3 個 Prompt 模板
    • 挑一個課程 / 產品線 / 專案,每次產出新文件就丟進 NotebookLM,開始養成「一專案一 Notebook」的習慣
  • 96 個 Gemini Agent 幫你寫系統?

    96 個 Gemini Agent 幫你寫系統?

    📌 本文重點

    • 多 Agent 可複製「多人分工」開發流程
    • Runtime 設計比單純換更大模型更關鍵
    • 用開源工具就能打造迷你版 Antigravity

    用一群 Agent 代替「一個工程師慢慢寫」,解決的是:複雜專案要靠多人分工,AI 也可以用 Runtime + 多代理系統做到同樣的協作和自動化

    核心觀念先講白:模型戰爭差不多打完了,現在比的是誰的 Agent Runtime 能把「模型能力」變成可落地的、多步驟的自動化工作流。

    Google 在 I/O 上展示的 Antigravity 2.0 + Gemini 3.5 Flash 是一個很極端的例子:

    • 96 個子代理分工
    • 12 小時寫完一套從零開始的作業系統
    • Token 成本不到 1,000 美金
    • OS 還能跑《Doom》

    💡 關鍵: 多代理 + 強 Runtime 已經能在「12 小時、不到 1,000 美金」內完成從零開發 OS,顯示關鍵瓶頸不再是模型本身,而是協作與流程設計。

    這不是叫你明天也去做一個 OS,而是提供一個「如何設計多 Agent 開發流程」的範本。下面我們拆成三件你可以直接抄的事:

    1. 多代理分工設計:任務 → 子任務 → Agent 編隊
    2. 強健 Runtime:重試、檢查點、錯誤恢復
    3. 平價版本實作:在你自己的專案做一個「迷你 Antigravity」

    核心功能:Antigravity 2.0 給開發者的三個啟示

    1. 多代理分工:任務 → 子任務 → Agent 編隊

    Antigravity 的做法,其實很像你帶一個遠端工程團隊:

    • 架構師 Agent:決定 OS 的模組切分(檔案系統、排程、驅動、UI…)
    • 模組作者 Agent:各自負責某一個模組的程式碼生成
    • 測試員 Agent:寫測試、跑測試、收斂錯誤
    • 整合者 Agent:把各模組組合、處理相依性、打包成可啟動的系統

    對你來說,可直接套用成一個通用流程:

    1. 寫一個頂層任務描述
      例:建立一個 RESTful CRUD 服務,管理任務(待辦事項),含 API、DB schema、簡單前端。

    2. 讓「架構師 Agent」自動拆解

    3. API 設計與 OpenAPI spec

    4. 後端框架與資料庫層
    5. 前端 UI
    6. 測試與 CI script

    7. 為每個子任務設計 Agent 角色

    8. api-architect-agent:只產出 API spec

    9. backend-agent:根據 spec 產生程式碼
    10. frontend-agent:負責 UI
    11. tester-agent:生成並執行測試
    12. integrator-agent:檢查專案結構、跑 build / lint

    13. 在 Runtime 中定義工作流

    14. 任務圖(DAG):架構師 → 模組作者 → 測試員 → 整合者

    15. 每個節點定義輸入/輸出檔案、工具(Git、DB、HTTP client)

    可行動步驟:

    • 選一個你熟的框架(例如 FastAPI / Next.js
    • 用自然語言寫清楚「最終可交付物」
    • 為這個專案定義 3–5 個 Agent 角色,明確限制各自輸入輸出

    2. Runtime 比模型重要:90% 成功率在多步任務會變災難

    多步任務有一個殘酷數學:

    • 假設每一步成功率 90%
    • 要跑 20 步,整體成功率 ≈ 0.9^20 ≈ 12%

    💡 關鍵: 即使單步有 90% 成功率,20 步工作流成功率只剩約 12%,所以不加 Runtime 管控,多步任務幾乎註定失敗。

    這就是為什麼像 Forge 這種開源 guardrails 會被重視:作者實測,一個 8B 模型在多步代理任務上,從 53% 提到 99% 成功率,完全不改模型,只改 Runtime。

    你在自己的「迷你 Antigravity」裡,要做三件事:

    1. 重試與 nudging

    2. 為每個步驟設 max_retries(例如 3 次)

    3. 失敗時自動加上「修正提示」,例如:上一步測試失敗,錯誤訊息如下,請修正而不是重寫整檔。

    4. 檢查點(checkpoint)

    5. 每完成一個重要子任務,就把中間產出存到 Git / DB

    6. 失敗時從最近的檢查點重跑,而不是重頭來

    7. 錯誤恢復流程

    8. 專門的 debug-agent:只看錯誤訊息 & log,產出修復建議

    9. Runtime 層做:自動建立 bug report、開 issue、指派給對應 Agent

    如果你用 Forge,它已內建:

    • Tool-agnostic 重試策略
    • 步驟執行強制與錯誤恢復
    • VRAM-aware context 管理(對本地模型很重要)
    • 評估套件與 Dashboard,可量化成功率

    可行動步驟:

    • 先把現有「單 Agent 自動流程」改成有重試與 checkpoint
    • 對每個任務記錄:總步數、失敗點、重試次數,在 Dashboard 裡看瓶頸

    3. 平價版本:你也能做一個「迷你 Antigravity」

    你不需要 Gemini 3.5 Flash + Google 內部 Runtime 才能玩多 Agent。下面這些工具可以在自家專案做一個縮小版:

    名稱 核心功能 免費方案 適合誰
    Forge 多步代理 guardrails、重試、Dashboard 開源 想提升本地 / 自架 LLM 可靠性的工程師
    llama.cpp + Qwen 本地 Agent 在個人電腦跑本地模型 + 簡易工具調用 開源 想省雲端費用、在內網跑 Agent 的團隊
    MCP 生態(如 OpenAI MCP、各種 server) 統一的工具協議,讓 Agent 調用資料庫、API 等 多數開源 / 免費 想把既有系統暴露為 Agent 工具的後端工程師

    一個實用組合示例:

    • 模型:Qwen 2.5 7B / 14B(透過 llama.cppOllama 跑)
    • Runtime:Forge 當 guardrails
    • 工具層:一組 MCP server(例如 PostgreSQL、HTTP、Filesystem)

    你可以先做一個「自動搭建 CRUD 服務」的迷你 Antigravity:

    1. 使用者輸入需求(自然語言)
    2. architect-agent 產出設計 + 任務拆解
    3. backend-agent + frontend-agent 寫程式碼
    4. tester-agent 自動開發 & 執行測試
    5. integrator-agentbuild 並回報狀態

    適合誰用:三種典型場景

    1. 後端 / 全端工程師:自動化 CRUD 小專案

    你可以把「打造新微服務」變成一個表單:

    • 輸入資料模型 + 幾個業務規則
    • 多 Agent 流程負責 scaffold、API、測試、docker-compose

    行動:從一個只需要 3–5 小時就能手刻完的小服務開始,先讓多 Agent 幫你做到 70–80%,你只負責 code review。


    2. 資料團隊:資料管線與 ETL 任務

    • planner-agent:解析需求、拆成抽取/轉換/載入步驟
    • sql-agent:產生查詢與 view
    • check-agent:比對 row count、品質指標

    行動:挑一個每天都在重複手動跑的 ETL 任務,做成標準流程,讓 Agent 幫你自動生成 SQL + 驗證報表。


    3. 產品 / PM:快速驗證 Side Project

    • 搭配 Gemini 3.5(雲端)或本地 LLM
    • 定義一個「最小可行功能」(例如 landing page + 簡單 API)
    • 用多 Agent 完成第一版,再丟給工程師接手

    行動:每次新點子,給自己一個規則:「先讓多 Agent 寫一版 Demo,我只在最後 2 小時調整。」


    怎麼開始:一個最小可行範例

    這裡給一條「3–5 小時內可完成」的路線,你可以直接照做:

    步驟 1:選模型 + Agent 框架

    • 模型:
    • 想省錢/本地:Qwen 2.5 7B(透過 llama.cppOllama
    • 想雲端無痛:Gemini 3.5 Flash(透過 Google AI Studio
    • Runtime / 框架:
    • 想要 guardrails:裝 Forge
    • 想用現成 MCP:選一個支援 MCP 的 Agent 框架(如 OpenAI 官方 Agent SDK)

    步驟 2:挑一個小系統

    條件:

    • 單服務、沒有第三方整合
    • 你自己寫大約 3–5 小時能完成

    例:任務管理 CRUD API + 簡單 React 前端

    步驟 3:設計任務拆分與 Agent 角色

    1. 任務描述寫成一個 markdown 檔(會給 architect-agent 看)
    2. 在 Runtime 中註冊 4 個 Agent:
    3. architect
    4. backend
    5. frontend
    6. tester/integrator
    7. 為每個 Agent 明確:
    8. 可用工具(Git、Filesystem、HTTP…)
    9. 輸入(上一個 Agent 的輸出 / 檔案)
    10. 必須產出什麼檔案

    步驟 4:加上監控 Dashboard

    • 如果用 Forge:直接啟用它的 Dashboard,看每次工作流的步驟成功率
    • 若自己實作:
    • 為每個步驟記錄:開始時間、結束時間、是否重試
    • 每次失敗時存 log + 輸入輸出到一個資料夾

    步驟 5:只做一件事的迭代

    • 第一版只要求「能跑起來」,不追求漂亮結構
    • 每次失敗,你只調整:
    • 任務拆分是否太粗/太細
    • Agent 提示是否太模糊
    • 重試與 checkpoint 是否設太少

    等到這個小系統穩定後,你才讓 Runtime 去碰更大的專案。


    小結:Runtime 是你的「AI 開發主管」

    Antigravity 2.0 用 96 個 Gemini Agent 寫出一套能跑《Doom》 的 OS,看起來很遠,但背後用到的概念其實都可落在你今天的 side project 上:

    • 把任務拆成 Agent 可接手的小單位
    • 用 Runtime 管控流程,而不是寄望模型每次都猜對
    • 利用開源工具(Forge、llama.cpp、MCP)做出自己的「迷你 Antigravity」

    💡 關鍵: 關鍵不是再換一個更大的模型,而是把現有模型放進可靠的 Runtime,讓它真的「交付」可用產物。

    關鍵不是再換一個更大的模型,而是先把你手上的模型,放進一個可靠的 Runtime 裡,讓它真的幫你「交付」東西。

    🚀 你現在可以做的事

    • 在 GitHub 上看看 Forge 專案,了解多步代理的 guardrails 怎麼設計
    • 挑一個 3–5 小時能手刻完的 CRUD 小服務,照文中的 4 個 Agent 角色拆任務實作一次
    • 把既有的單 Agent 自動化腳本,加上 max_retries 和簡單 checkpoint 機制,量化成功率變化