前言

使用 Claude Code、OpenAI Codex、OpenCode 等 AI Coding Agent 的機會越來越多了。讀取程式碼、編輯檔案、執行測試、修正錯誤,能夠自動完成多個步驟。

不過,實際使用時還是會產生疑問。

明明用的是同一個 LLM,為什麼不同工具的準確度和使用體驗會不一樣?

其中一個原因,就是 LLM 周圍的機制,Agent Harness。LangChain 的文章 The Anatomy of an Agent Harness 也把 Agent 視為 Model 與 Harness 的組合。

本文會整理概念,並用約 150 行 Python 實作一個小型 Harness。實際跑看看,確認 Harness 所承擔的角色。

1. LLM 與 AI Agent 有什麼不同

LLM 是根據輸入預測下一個 token,進而生成文章或程式碼的模型。例如,對以下需求可以回傳實作範例。

請用 Laravel 建立一個取得使用者列表的 API。

但在實際開發中,只輸出程式碼並不算完成。

  • 讀取既有的專案結構
  • 檢查相關檔案
  • 編輯檔案
  • 執行測試
  • 如果失敗就找原因並修正
  • 最後確認變更內容

LLM 單獨運作時,無法直接存取外部檔案或程序。這時就需要能讓這些行為成真的機制。

2. 什麼是 Agent Harness

Harness 是位於 LLM 外部,將模型輸出連接到實際行動的執行與控制機制。它包含模型以外的程式碼、設定、工具、執行環境、控制邏輯等。

Agent = LLM + Harness

如果用作業系統來比喻,LLM 像 CPU,而 Harness 則比較像負責檔案系統、程序管理、權限管理等的作業系統。不過這只是幫助理解的比喻,並非嚴格對應關係。

「Agent = LLM + Harness」也是為了整理概念的表達方式,並不是業界共通的嚴格定義。依照語境或供應商不同,Harness、Framework、Scaffold 等用語的範圍也會不同。

3. Harness 的組成要素

實作會因專案而異,但 Coding Agent 的 Harness 通常包含以下功能。

要素角色Coding Agent 中的例子工具存取外部環境的方法檔案讀寫、搜尋、終端機、Git上下文管理管理要傳給模型的資訊歷史摘要、輸出截斷狀態・記憶保存作業進度與資訊TODO、計劃檔、備忘錄執行環境執行程式碼與指令的地方容器、VM、沙箱計畫・協調管理任務與執行順序任務分解、子代理守門機制控制可執行的操作核准、權限、限制可觀測性追蹤執行情況日誌、追蹤、時間與成本記錄不需要一開始就全部實作。這次只聚焦在工具、簡易守門機制、可觀測性、上下文保護。

4. 實際跑跑看:最小化的 Harness

Harness 的基本流程如下。

LLM 要求呼叫工具,Harness 負責執行。然後把結果加入對話歷史,再回傳給 LLM。這個循環會持續到不再有工具呼叫,或達到設定上限為止。

以下動作確認使用 Python 3.12 進行。程式碼使用了 Path | None 之類的寫法,因此需要 Python 3.10 以上。

4.1 Harness 本體(harness.py)

與實際模型連接時使用 Anthropic SDK。Harness 的基本邏輯本身只用標準函式庫撰寫。

"""一個小型、教學用的 Agent Harness(Python 3.10+)。僅使用標準函式庫;實際模式需要 Anthropic SDK。"""
import json
import os
import shlex
import subprocess
import sys
import tempfile
import time
from pathlib import Path

BASE_DIR = Path(__file__).resolve().parent
WORKDIR = (BASE_DIR / "workspace").resolve()
TRACE_PATH = BASE_DIR / "trace.jsonl"
MAX_OUTPUT = 4_000
MAX_STEPS = 15
TIMEOUT_SECONDS = 60
# 為了便利而設的允許清單,並不是安全邊界
# (write_file 寫出的測試程式,可能會在未經核准下直接執行)
SAFE_COMMAND_PREFIXES = (("python", "-m", "unittest"), ("python3", "-m", "unittest"))

SYSTEM = (
    "你是一個程式開發助理。請讀取工作區內的檔案、執行測試,"
    "如果失敗就修正程式碼,再次測試並確認結果後再回報。"
)
TOOLS = [
    {
        "name": "read_file",
        "description": "讀取工作區內的檔案",
        "input_schema": {"type": "object", "properties": {"path": {"type": "string"}}, "required": ["path"]},
    },
    {
        "name": "write_file",
        "description": "寫入工作區內的檔案",
        "input_schema": {
            "type": "object",
            "properties": {"path": {"type": "string"}, "content": {"type": "string"}},
            "required": ["path", "content"],
        },
    },
    {
        "name": "run_command",
        "description": "在工作區中執行指令。不使用 shell,因此不能使用管線、&&、cd。"
                       "不在允許清單內的指令,執行前會要求核准",
        "input_schema": {"type": "object", "properties": {"cmd": {"type": "string"}}, "required": ["cmd"]},
    },
]

def safe_path(relative_path: str) -> Path:
    """拒絕離開工作區的路徑(包含經由符號連結的情況)"""
    target = (WORKDIR / relative_path).resolve()
    if not target.is_relative_to(WORKDIR):
        raise ValueError("無法存取工作區外的路徑")
    return target

def truncate(text: str) -> str:
    """以字元數限制輸出(不是 token 數)。錯誤通常出現在末尾,因此保留尾端"""
    return text if len(text) <= MAX_OUTPUT else "...(省略前段)...\n" + text[-MAX_OUTPUT:]

def is_safe_command(argv: list[str]) -> bool:
    return any(argv[: len(prefix)] == list(prefix) for prefix in SAFE_COMMAND_PREFIXES)

def approve(argv: list[str], auto_yes: bool = False) -> bool:
    """不在允許清單內的指令,必須等人類核准後才能執行"""
    if is_safe_command(argv) or auto_yes:
        return True
    return input(f"可以執行嗎? {shlex.join(argv)} [y/N] ").strip().lower() == "y"

def run_tool(name: str, args: dict, auto_yes: bool = False) -> str:
    try:
        if name == "read_file":
            return truncate(safe_path(args["path"]).read_text(encoding="utf-8"))
        if name == "write_file":
            target = safe_path(args["path"])
            target.parent.mkdir(parents=True, exist_ok=True)
            target.write_text(args["content"], encoding="utf-8")
            return "已寫入"
        if name == "run_command":
            argv = shlex.split(args["cmd"])
            if not argv:
                return "錯誤:指令為空"
            if not approve(argv, auto_yes):
                return "使用者拒絕執行"
            # 每次執行都使用空的 .pyc 快取位置,避免重用舊快取
            with tempfile.TemporaryDirectory(prefix="agent-pycache-") as cache_dir:
                result = subprocess.run(
                    argv, cwd=WORKDIR, capture_output=True, text=True, timeout=TIMEOUT_SECONDS,
                    env={**os.environ, "PYTHONPYCACHEPREFIX": cache_dir},
                    shell=False,  # 不會解讀 shell 運算子。不過這不是 OS 層級的沙箱
                )
            return truncate(f"exit={result.returncode}\n{result.stdout}{result.stderr}")
        return f"未知的工具:{name}"
    except Exception as exc:
        return f"錯誤:{type(exc).__name__}: {exc}"

def summarize_input(name: str, args: dict) -> dict:
    """供追蹤記錄使用的輸入摘要。寫入檔案的內容不會留在日誌裡"""
    if name == "write_file":
        return {"path": args.get("path"), "content_chars": len(args.get("content", ""))}
    return args

def log(event: dict, path: Path | None = None) -> None:
    """將追蹤資訊以 JSON Lines 格式逐行追加"""
    path = path or TRACE_PATH
    record = {**event, "ts": round(time.time(), 3)}
    with path.open("a", encoding="utf-8") as stream:
        stream.write(json.dumps(record, ensure_ascii=False) + "\n")

def agent(client, model: str, task: str, max_steps: int = MAX_STEPS, auto_yes: bool = False) -> str:
    messages = [{"role": "user", "content": task}]
    for step in range(max_steps):
        response = client.messages.create(
            model=model, max_tokens=4096, system=SYSTEM, tools=TOOLS, messages=messages,
        )
        messages.append({"role": "assistant", "content": response.content})
        log({"step": step, "stop_reason": response.stop_reason})

        if response.stop_reason != "tool_use":
            return "".join(block.text for block in response.content if block.type == "text")

        tool_results = []
        for block in response.content:
            if block.type == "tool_use":
                output = run_tool(block.name, block.input, auto_yes)
                log({"step": step, "tool": block.name,
                     "input": summarize_input(block.name, block.input), "output_head": output[:200]})
                tool_results.append({"type": "tool_result", "tool_use_id": block.id, "content": output})
        messages.append({"role": "user", "content": tool_results})
    return "已達到最大步數"

if __name__ == "__main__":
    import anthropic  # 僅在使用實際模型時需要:pip install anthropic

    WORKDIR.mkdir(parents=True, exist_ok=True)
    task = sys.argv[1] if len(sys.argv) > 1 else "請執行 workspace 的測試,如果失敗就修正。"
    model = os.environ.get("ANTHROPIC_MODEL", "claude-sonnet-4-6")
    print(agent(anthropic.Anthropic(), model, task))

程式碼與 Harness 要素的對應如下。

Harness 的要素程式碼上的對應工具TOOLS 與 run_tool守門機制approve、safe_path(簡易控制)上下文保護truncate(將工具輸出限制在最多 4,000 字元)從失敗中恢復將工具錯誤或測試結果以字串形式回傳給模型可觀測性log(將事件記錄到 trace.jsonl)防止失控max_steps 與指令執行的 timeouttruncate 是以字元數限制,並不是在計算 token 數。此外,保留尾端的方式也可能讓前面的重要資訊被截掉。實際的 Harness 也可以針對不同工具型態設計摘要與重要資訊擷取。

安全注意事項

  • 這個範例使用 shell=False,並將路徑操作限制在工作區內。不過,已核准的程式仍會以目前 OS 使用者權限執行,仍有可能存取工作區外的檔案。這不是安全的沙箱。
  • python3 -m unittest 會在未核准的情況下執行,但這只是為了便利而做的設定,並不是安全邊界。因為它可能直接執行用 write_file 寫出的測試程式(本文也有實際驗證)。
  • 若要執行不受信任的程式碼,請使用容器或專用使用者等方式隔離。

4.2 不用 API Key 也能驗證運作(test_harness.py)

即使沒有 LLM,也可以測試 Harness 的迴圈、工具執行、結束條件等。只要用模擬 messages.create 的 FakeClient,按照預先設定的順序回傳固定回應即可。

"""Harness 控制邏輯的離線測試(不需要 API key 與網路)"""
import os
import shlex
import subprocess
import tempfile
import unittest
from itertools import count
from pathlib import Path
from types import SimpleNamespace as NS
from unittest.mock import patch

import harness

_IDS = count(1)

def tool(name, **inputs):
    return NS(type="tool_use", id=f"tool_{next(_IDS)}", name=name, input=inputs)

def text_block(text):
    return NS(type="text", text=text)

class FakeClient:
    """依序回傳預先設定的應答。驗證的不是模型推理,而是 Harness 的邏輯"""

    def __init__(self, script):
        self.script = list(script)
        self.calls = []
        self.messages = NS(create=self._create)

    def _create(self, **kwargs):
        self.calls.append(kwargs)
        if not self.script:
            raise AssertionError("FakeClient 的腳本已用完")
        blocks = self.script.pop(0)
        stop = "tool_use" if any(b.type == "tool_use" for b in blocks) else "end_turn"
        return NS(content=blocks, stop_reason=stop)

class HarnessTests(unittest.TestCase):
    def setUp(self):
        self.temp = tempfile.TemporaryDirectory()
        self.old_workdir, self.old_trace = harness.WORKDIR, harness.TRACE_PATH
        harness.WORKDIR = Path(self.temp.name) / "workspace"
        harness.TRACE_PATH = Path(self.temp.name) / "trace.jsonl"
        harness.WORKDIR.mkdir()
        (harness.WORKDIR / "calc.py").write_text("def add(a, b):\n    return a - b\n", encoding="utf-8")
        (harness.WORKDIR / "test_calc.py").write_text(
            "import unittest\nfrom calc import add\n\n"
            "class TestAdd(unittest.TestCase):\n"
            "    def test_add(self):\n"
            "        self.assertEqual(add(2, 3), 5)\n",
            encoding="utf-8",
        )

    def tearDown(self):
        harness.WORKDIR, harness.TRACE_PATH = self.old_workdir, self.old_trace
        self.temp.cleanup()

    def test_agent_fix_cycle_failure_then_success(self):
        run_tests = "python3 -m unittest -q"
        fixed = "def add(a, b):\n    return a + b\n"
        client = FakeClient([
            [text_block("先執行測試"), tool("run_command", cmd=run_tests)],
            [tool("read_file", path="calc.py")],
            [tool("write_file", path="calc.py", content=fixed)],
            [tool("run_command", cmd=run_tests)],
            [text_block("已修正,並確認測試通過")],
        ])
        output = harness.agent(client, "fake-model", "請修正測試")
        self.assertIn("確認", output)
        self.assertEqual((harness.WORKDIR / "calc.py").read_text(encoding="utf-8"), fixed)
        trace = harness.TRACE_PATH.read_text(encoding="utf-8")
        self.assertIn("exit=1", trace)
        self.assertIn("exit=0", trace)
        self.assertEqual(len(client.calls), 5)

    def test_path_traversal_rejected(self):
        self.assertTrue(harness.run_tool("read_file", {"path": "../outside.txt"}).startswith("錯誤:"))

    def test_symlink_escape_rejected(self):
        outside = Path(self.temp.name) / "outside.txt"
        outside.write_text("private", encoding="utf-8")
        (harness.WORKDIR / "outside-link").symlink_to(outside)  # Windows 可能需要權限
        self.assertTrue(harness.run_tool("read_file", {"path": "outside-link"}).startswith("錯誤:"))

    def test_max_steps_stops_loop(self):
        client = FakeClient([[tool("read_file", path="calc.py")] for _ in range(4)])
        output = harness.agent(client, "fake-model", "continue", max_steps=2)
        self.assertIn("已達到最大步數", output)
        self.assertEqual(len(client.calls), 2)

    def test_non_allowlisted_command_requires_approval(self):
        with patch("builtins.input", return_value="n"):
            output = harness.run_tool("run_command", {"cmd": "rm -rf workspace"})
        self.assertIn("拒絕", output)
        self.assertTrue((harness.WORKDIR / "calc.py").exists())

    def test_shell_metacharacters_are_not_auto_approved(self):
        cmd = "python3 -m unittest; echo INJECTED"
        self.assertFalse(harness.is_safe_command(shlex.split(cmd)))
        with patch("builtins.input", return_value="n"):
            self.assertIn("拒絕", harness.run_tool("run_command", {"cmd": cmd}))

    def test_unittest_command_is_allowlisted(self):
        self.assertTrue(harness.is_safe_command(["python3", "-m", "unittest", "-q"]))
        self.assertTrue(harness.is_safe_command(["python", "-m", "unittest"]))

    def test_allowlist_is_not_a_security_boundary(self):
        """已知限制的記錄:用 write_file 寫出的測試會在未核准下執行"""
        marker = Path(self.temp.name) / "ran-outside-workspace.txt"
        harness.run_tool("write_file", {"path": "test_evil.py", "content": (
            "import unittest, pathlib\n"
            "class T(unittest.TestCase):\n"
            f"    def test_x(self):\n        pathlib.Path({str(marker)!r}).write_text('x')\n")})
        with patch("builtins.input", side_effect=AssertionError("不應該要求核准")):
            harness.run_tool("run_command", {"cmd": "python3 -m unittest -q"})
        self.assertTrue(marker.exists())

    def test_fresh_bytecode_cache_avoids_stale_module(self):
        source = harness.WORKDIR / "cached_module.py"
        source.write_text("VALUE = 1\n", encoding="utf-8")
        subprocess.run(["python3", "-c", "import cached_module"], cwd=harness.WORKDIR,
                       check=True, capture_output=True)
        old_mtime = source.stat().st_mtime
        source.write_text("VALUE = 2\n", encoding="utf-8")  # 同大小覆寫
        os.utime(source, (old_mtime, old_mtime))            # mtime 也改回去
        with patch("builtins.input", return_value="y"):
            output = harness.run_tool(
                "run_command", {"cmd": "python3 -c 'import cached_module; print(cached_module.VALUE)'"})
        self.assertIn("exit=0\n2", output)

    def test_write_file_creates_nested_directories(self):
        out = harness.run_tool("write_file", {"path": "nested/new.py", "content": "print('ok')"})
        self.assertEqual(out, "已寫入")
        self.assertEqual((harness.WORKDIR / "nested/new.py").read_text(encoding="utf-8"), "print('ok')")

    def test_truncate_keeps_tail(self):
        result = harness.truncate("A" * (harness.MAX_OUTPUT + 10) + "TAIL")
        self.assertTrue(result.startswith("...(省略前段)..."))
        self.assertTrue(result.endswith("TAIL"))
        self.assertLessEqual(len(result), harness.MAX_OUTPUT + 30)

    def test_trace_does_not_store_written_file_contents(self):
        secret = "API_KEY=sk-demo-" + "x" * 40
        client = FakeClient([
            [tool("write_file", path="a.env", content=secret)],
            [text_block("完成")],
        ])
        harness.agent(client, "fake-model", "請寫入")
        trace = harness.TRACE_PATH.read_text(encoding="utf-8")
        self.assertNotIn(secret, trace)
        self.assertIn('"content_chars"', trace)
        self.assertEqual((harness.WORKDIR / "a.env").read_text(encoding="utf-8"), secret)

if __name__ == "__main__":
    unittest.main(verbosity=2)

這些測試驗證的不是 LLM 的推理能力,而是 Harness 的控制邏輯。可以確認工具執行、結果傳遞、結束條件、路徑限制、日誌內容等。

執行方式:

python3 -m unittest -v

最後如果顯示 Ran 12 tests ... OK 就代表成功。這不需要 API key 或網路。另請注意,測試是以 python3 指令為前提,符號連結測試在 Windows 上可能需要管理員權限等條件。

4.3 連接實際模型

如果要使用實際模型,請先安裝 SDK,並設定 API key 與模型名稱。

pip install anthropic
export ANTHROPIC_API_KEY="your-api-key"
export ANTHROPIC_MODEL="your-model-name"
python3 harness.py

Windows PowerShell 的環境變數設定方式不同。

agent() 的結構是呼叫 client.messages.create。FakeClient 與實際 SDK client 使用相同的呼叫介面,因此可以切換測試回應與實際模型。不過,實際模型的工具呼叫與推理品質,無法由 FakeClient 的測試驗證。

執行後可以查看 trace.jsonl。這是用來追蹤每個 step 發生了什麼事的簡易日誌。它不會記錄寫入檔案的內容,但命令與讀取結果的開頭可能包含機密資訊,因此在分享或公開前請先確認。

5. 實作時遇到的問題:Python 的 bytecode cache

在測試過程中,曾出現明明已經修改原始碼,卻還是得到舊結果的情況。

Python 在 import 時會使用 bytecode cache(.pyc)。在 timestamp-based cache 的情況下,會根據修改時間與檔案大小等資訊判斷快取是否有效。因此,如果在同一秒內改寫成同樣大小的檔案等條件重疊,就可能重現舊快取被使用的情況。

這次實驗中,我們透過改寫同大小的來源檔,並把 mtime 改回原值,確認舊快取會被讀取。

一開始以為用 PYTHONDONTWRITEBYTECODE=1 就能解決,但這只會抑制 bytecode cache 的寫入,無法阻止既有 .pyc 的讀取。實際測試時,在已存在 .pyc 的情況下,即使加上這個設定,仍然會回傳舊值。

因此,這個 Harness 會在每次執行指令時指定一個暫存快取目錄。

with tempfile.TemporaryDirectory(prefix="agent-pycache-") as cache_dir:
    result = subprocess.run(
        argv,
        cwd=WORKDIR,
        env={**os.environ, "PYTHONPYCACHEPREFIX": cache_dir},
        shell=False,
        ...,
    )

設定 PYTHONPYCACHEPREFIX 後,Python 會改用這個空目錄,而不是既有的 __pycache__ 作為快取位置。臨時目錄會在指令結束後刪除,因此不會重用前一次執行產生的快取。test_fresh_bytecode_cache_avoids_stale_module 也確認了,若移除此設定,測試有可能失敗。這仍然不是萬能的 Python 執行環境解法,只是為了避免這個範例受到快取影響的方法。

LLM 看到的只是「測試失敗」的結果。即使實際上修正是對的,只要執行環境讀到的是舊程式碼,模型就可能開始往錯誤方向尋找原因。

模型的推理能力,和 Harness 所提供的執行環境是否正確,是兩個不同的問題。

6. 以角色整理 Framework、Runtime、Harness

在 Agent 相關領域中,常會出現 Framework、Runtime、Harness 這些詞。若大致依角色整理,可如下理解。

用語主要角色舉例Agent Framework提供組裝 Agent 所需的抽象層與元件LangChain、CrewAI、Google ADK 等Agent Runtime負責 Agent 的執行、狀態管理、續跑等機制LangGraph 等。一般的 Workflow Runtime 也屬於相關領域Agent Harness模型周圍負責執行、控制、工具、上下文、守門等的機制自製 Harness、Coding Agent 的執行基礎等不過,這些界線並不完全分明。有些像 LangGraph 這類工具會同時扮演多種角色;也有像 Temporal 這種通用 Workflow Engine 被拿來用於 Agent 執行的案例。

比起分類產品名稱,確認它提供哪些功能,以及哪些部分能由自己控制,會更實際。

7. Harness 設計會改變 Agent 的結果嗎

即使使用相同的 LLM,根據 Harness 的設計不同,結果也可能不同。例如以下情況:

  • 沒有讀到必要檔案,導致修正錯誤
  • 工具執行結果沒有反映到上下文中,因此無法解決問題
  • 因為整理上下文而遺失重要資訊
  • 修正後沒有再次驗證,就在問題其實還沒解決時結束
  • 執行環境有問題,導致執行的是舊程式碼而不是修正版

也就是說,Agent 的結果不只取決於模型能力,也受模型拿到的資訊與執行環境影響。像 truncate 會考慮錯誤常出現在輸出尾端,因此保留尾端,這也是設計判斷的一種。

在更大規模的案例中,也有透過改善 Harness 提升效能的報告。LangChain 的 deepagents-cli 分數從 52.8% 提升到 66.5% 這個數字,曾被作為二手資料介紹,但本文無法確認第一手來源。請注意不要在未確認基準條件的情況下,將它直接視為一般性的效能提升。

8. 需要多完整的 Harness

不是所有應用都需要複雜的 Harness。

使用者輸入 → LLM API → 回應

如果一次 API 呼叫就能滿足需求,那就夠了。當出現以下需求時,可以考慮導入 Harness:

  • 需要使用多個工具
  • 需要執行多步驟流程
  • 需要保留進度或狀態
  • 需要與外部系統整合
  • 失敗時需要重試
  • 需要驗證執行結果
  • 需要人工核准
  • 需要長時間執行

Anthropic 的 Building effective agents 也提到,應該先從簡單結構開始,需要時再增加複雜度。本文的程式也只保留最少必要元素。像是上下文壓縮、持久化狀態管理、多 Agent 等,都是在有需要時再加入的方針。

9. 個人經驗:同一個模型,接上的 Harness 不同,行為也不同

我對 Harness 差異最有感的,是使用 OpenCode 的時候。

  • 在 OpenCode 的 IDE 中,模型運作正常
  • 用同一組金鑰透過另一個 Harness 使用時,卻出現 quota exhausted 錯誤
  • 直接用 curl 呼叫 endpoint 時,則回傳 MissingSessionID

當時還沒有確認原因。除了 Harness 之外,請求格式、標頭、session 資訊、Provider 端的路由與 quota 處理方式等,都有可能是原因。

因此,可以提出「可能需要像 session ID 這類額外資訊」的假設,但目前還不能直接斷定這就是原因。

這段經驗讓我學到兩件事。

  1. 即使以為是「模型壞了」,也要懷疑模型以外的層。 要固定模型、金鑰、連線目標等條件,並一個一個切分變因。
  2. 看不到的東西很難排查。 如果無法確認送出的請求和收到的回應,就很難縮小原因範圍。Harness 內的日誌與追蹤也因此很重要。

總結

  • Agent Harness 是把 LLM 的輸出連接到實際行動的執行與控制機制
  • Agent 的基本循環是「LLM → 執行工具 → 將結果放回上下文 → LLM」的重複
  • 工具、上下文、守門機制、可觀測性、執行環境等設計都會影響 Agent 的結果
  • 核准與允許清單雖然方便,但不能單獨構成安全邊界。執行不受信任的程式碼時,請使用隔離環境
  • 自己實作 Harness 之後,更容易理解 AI Coding Agent 哪些交給模型,哪些是周邊程式在負責
  • 一開始先做簡單版本,再逐步加入需要的功能

在比較 AI Coding Agent 時,除了看「用了哪個模型」之外,也可以把「支撐這個模型的是什麼樣的 Harness」納入考量,這會是理解差異的線索之一。

參考

※ 本文撰寫與程式驗證使用了 AI 助理。


原文出處:https://qiita.com/yamamoto_a_genee/items/76562c5c80032ad9e962


精選技術文章翻譯,幫助開發者持續吸收新知。

共有 0 則留言


精選技術文章翻譯,幫助開發者持續吸收新知。
🏆 本月排行榜
🥇
boluoji
📝52   💬3   ❤️8
1,389
🥈
我愛JS
📝3   💬1   ❤️5
148
🥉
站長阿川
📝2   💬3   ❤️2
67
評分標準:發文×10 + 留言×3 + 獲讚×5 + 點讚×1 + 瀏覽數÷10
本數據每小時更新一次
📢 贊助商廣告 · 我要刊登