2
0

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?

Agent Harnessを理解するために、150行ほどのPythonで自作してみた

2
Posted at

はじめに

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 は入力をもとに、次に続くトークンを予測して文章やコードを生成するモデルです。たとえば、次のような依頼に実装例を返せます。

Laravel でユーザー一覧を取得する API を作成してください。

しかし、実際の開発ではコードを出力するだけでは完了しません。

  • 既存のプロジェクト構造を読む
  • 関連ファイルを調べる
  • ファイルを編集する
  • テストを実行する
  • 失敗したら原因を調べて修正する
  • 最後に変更内容を確認する

LLM 単体では、外部のファイルやプロセスに直接アクセスできません。このような行動を可能にする仕組みが必要です。

2. Agent Harness とは

Harness は、LLM の外側にあり、モデルの出力を実際の行動につなげる実行・制御の仕組みです。モデル以外のコード、設定、ツール、実行環境、制御ロジックなどを含みます。

Agent = LLM + Harness

OS にたとえるなら、LLM が CPU、Harness がファイルシステムやプロセス管理、権限管理などを担う OS に近い存在、と考えるとイメージしやすいかもしれません。ただし、これは理解のための比喩であり、厳密な対応関係ではありません。

「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 の基本ロジック自体は標準ライブラリだけで書いています。

"""A small, educational Agent Harness (Python 3.10+). Stdlib only; Anthropic SDK is needed for live mode."""
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": "ワークスペースでコマンドを実行する。シェルは使わないため、パイプ・&&・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:
    """出力を文字数で制限する(トークン数ではない)。エラーは末尾に出やすいので末尾を残す"""
    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,  # シェル演算子は解釈されない。ただし 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 で 1 行追記する"""
    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 とコマンド実行の timeout

truncate は文字数で制限しており、トークン数を計算しているわけではありません。また、末尾を残す方式では先頭の重要情報が落ちる可能性があります。実際の Harness では、ツールの種類に応じた要約や重要情報の抽出も検討できます。

セキュリティ上の注意

  • このサンプルは shell=False を使い、パス操作をワークスペース内に制限しています。しかし、承認したプログラムは現在の OS ユーザー権限で動き、ワークスペース外のファイルにもアクセスできる可能性があります。安全なサンドボックスではありません。
  • python3 -m unittest は承認なしで実行されますが、これは利便性のための設定であり、安全性の境界ではありません。write_file で書いたテストコードを、そのまま承認なしで実行できてしまうためです(この挙動はテストでも確認しています)。
  • 信頼できないコードを実行する場合は、コンテナや専用ユーザーなどで隔離してください。

4.2 API キーなしで動作確認する(test_harness.py)

Harness のループやツールの実行、終了条件などは、LLM がなくても検証できます。messages.create を模倣した FakeClient に、決められた応答を順番に返させます。

"""Harness の制御ロジックのオフラインテスト(API キー・ネットワーク不要)"""
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 キーやネットワークは不要です。なお、テストは python3 コマンドを前提にしており、シンボリックリンクのテストは Windows では管理者権限などが必要な場合があります。

4.3 実モデルにつなぐ

実モデルを使う場合は SDK をインストールし、API キーとモデル名を設定します。

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 クライアントは同じ呼び出しインターフェースを使うため、テスト用の応答と実モデルを切り替えられます。ただし、実モデルのツール呼び出しや推論品質は、FakeClient のテストでは検証されません。

実行後は trace.jsonl を確認できます。どの step で何が起きたかを追うための簡易ログです。書き込んだファイルの中身は記録しませんが、コマンドや読み取り結果の冒頭には機密情報が含まれる可能性があるため、共有・公開前に確認してください。

5. 実装中に遭遇した問題:Python の bytecode cache

テストを実行していた際、ソースコードを修正したのに古い結果が出るケースがありました。

Python は import 時に bytecode cache(.pyc)を利用します。timestamp-based cache の場合、更新時刻とファイルサイズなどの情報を使って cache の有効性を判断します。そのため、同じ秒に同じサイズのファイルを書き換えるなど、条件が重なると古い cache が使われるケースを再現できました。

今回の実験では、同じサイズのソースを書き換え、mtime を元に戻すことで古い cache が読み込まれることを確認しました。

最初は PYTHONDONTWRITEBYTECODE=1 で対処できると考えましたが、これは bytecode cache の書き込みを抑える設定で、既存の .pyc の読み込みまでは防げません。実際に、すでに .pyc がある状態で試すと、この設定を付けても古い値が返ってきました。

そこで、この Harness ではコマンド実行ごとに一時 cache directory を指定するようにしています。

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__ ではなく、この空のディレクトリを cache の置き場として使います。一時ディレクトリはコマンド終了後に削除されるため、以前の実行で作られた cache を再利用しません。test_fresh_bytecode_cache_avoids_stale_module は、この設定を外すと失敗することも確認しています。これも万能な Python 実行環境対策ではなく、このサンプルで cache の影響を避けるための方法です。

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 が必要なわけではありません。

User Input → LLM API → Response

1 回の API 呼び出しで目的を満たすなら、それで十分です。次のような要件が増えてきたら Harness の導入を検討できます。

  • 複数のツールを使う
  • 複数ステップを実行する
  • 進捗や状態を保持する
  • 外部システムと連携する
  • エラー時にリトライする
  • 実行結果を検証する
  • 人間の承認が必要
  • 長時間実行する

Anthropic の Building effective agents でも、まずシンプルな構成から始め、必要になったら複雑さを追加する考え方が紹介されています。今回のコードも最小限の要素に絞りました。コンテキストの圧縮や永続的な状態管理、複数 Agent などは、必要になってから追加する方針です。

9. 個人的な体験:同じモデルでも接続する Harness によって動作が違った

Harness の違いを実感したのは、OpenCode を使っていたときです。

  • OpenCode の IDE では、モデルが問題なく動作する
  • 同じキーを別の Harness 経由で利用すると quota exhausted エラーが出る
  • curl でエンドポイントを直接呼ぶと MissingSessionID が返る

この時点では、原因を特定できていません。Harness だけでなく、リクエスト形式、ヘッダー、セッション情報、Provider 側のルーティングや quota の扱いなど、複数の可能性があります。

そのため、セッション ID のような追加情報が必要なのかもしれない、という仮説は立てられますが、現時点で原因と断定することはできません。

この体験から学んだことは 2 つあります。

  1. 「モデルが動かない」と思っても、モデル以外の層を疑う。 モデル、キー、接続先などを固定し、変更する要素を一つずつ切り分けることが大切です。
  2. 観測できないものは切り分けにくい。 送信したリクエストと返ってきたレスポンスを確認できないと、原因の候補を絞れません。Harness でもログやトレースは重要な役割を担います。

まとめ

  • Agent Harness は、LLM の出力を実際の行動につなげる実行・制御の仕組み
  • Agent の基本ループは「LLM → ツール実行 → 結果をコンテキストに戻す → LLM」の繰り返し
  • ツール、コンテキスト、ガードレール、可観測性、実行環境などの設計は Agent の結果に影響する
  • 承認や許可リストは便利だが、それだけでは安全の境界にならない。信頼できないコードは隔離環境で動かす
  • Harness を自作すると、AI Coding Agent が何をモデルに任せ、何を周囲のコードが担っているかを理解しやすくなる
  • 最初はシンプルに作り、必要な機能を段階的に追加する

AI Coding Agent を比較するときは、「どのモデルを使っているか」だけでなく、「そのモデルをどんな Harness が支えているか」も意識してみると、違いを理解する手がかりになると思います。

参考

※ 本記事の執筆・コード検証には AI アシスタントを利用しています。

2
0
0

Register as a new user and use Qiita more conveniently

  1. You get articles that match your needs
  2. You can efficiently read back useful information
  3. You can use dark theme
What you can do with signing up
2
0

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?