HN 日本語サマリー

← 一覧へ戻る
AI・機械学習

高度なエージェントハーネスの構築

Building an Advanced Agentic Harness (data4sci.com)

105 pointsby Anon8441 コメント

要約

この記事では、単一のLLM呼び出しを、計画、実行、回復、および正当性の証明ができる信頼性の高いシステムに変換する方法を探求しています。単純なループから、型付きツール、プランDAG、階層メモリ、検証階層、予算、トレーサーといった構成要素を組み合わせ、薄いオーケストレーターでそれらを連携させることで、堅牢なエージェントシステムを構築するアプローチを解説しています。これにより、LLMエージェントの信頼性、安全性、デバッグ可能性、測定可能性を向上させます。

全文翻訳

高度なエージェントハーネスの構築

基本的なハーネスのループは正しいですが、ナイーブです。よくできたジェット機に乗った一人のパイロットはドッグファイトに勝てるかもしれませんが、誰もそのように航空作戦を実行しません。実際の作戦では、誰かが離陸する前にどの出撃を飛ばすかを決定するミッションプランナー、並行して独立した出撃を飛ばす部隊、燃料が尽きる前に基地への帰還を強制する燃料予算とビンゴコール、事後にすべてのミッションを再構築可能にするフライトレコーダー、そしてミッションが実際に成功したかどうかを判断する事後レビューが追加されます。これらのどれもパイロットに取って代わるものではありません。それらはパイロットを構造で包み込み、システム全体を高速、安全、デバッグ可能、そして測定可能に保ちます。

Claude Code、Devin、Cursor、Hermes、その他のプロダクションエージェントは、基本的なループに対してまったく同じことを行います。この記事では、フレームワークの背後にメカニズムを隠すことなく、基本的なハーネスのすべての部分をプロダクションの形状にアップグレードします。この演習全体を導く質問は単純なものです。

単一のLLMコールを、計画、実行、回復、そして正しいことを行ったことを証明できる信頼性の高いシステムにどうやって変えるのか?

私たちの答えはコンポジションです。私たちは小さくテスト可能なプリミティブを構築します。型付きツール、プランのDAG、階層化されたメモリ、検証階層、予算、そしてトレーサーであり、これらを意図的に薄いオーケストレーターで配線します。各プリミティブは、ナイーブなエージェントが特定の予測可能な方法で失敗するからです。LLMは無効なツール引数を生成するため、型付きツールとPydantic検証を追加します。すべてが逐次実行されるため、依存関係グラフと並列実行を追加します。コンテキストウィンドウがジャンクでいっぱいになるため、検索予算の下でマルチティアメモリを追加します。悪い出力がサイレントに伝播するため、検証階層を追加します。1つのプロンプトがすべてをやろうとするため、それをプランナー、ワーカー、そしてクリティックの役割に分割します。コストが暴走するため、段階的な劣化を伴うマルチディメンションの予算編成を追加します。

ハーネスが通常機能することを証明するには、評価スイート、検索ベンチマーク、および特殊化されたワーカープールを使用して、将来の記事で完全に扱います。

実行例

記事全体を通して、都市比較エージェントを構築します。都市のリストが与えられると、人口、タイムゾーン、および各都市の短い物語風の要約を比較するレポートを生成します。このタスクはほとんど侮辱的に単純に見えますが、慎重に選択されました。各都市属性のルックアップは、他のどのルックアップとも独立しています。これは、3都市のリクエストが自然に9つのツール呼び出しに分解され、それらすべてを同時に実行できることを意味します。一方、最終レポートは、すべてのルックアップが完了することに依存しているため、私たちは平坦なステップリストをはるかに超えています。要求されたすべての都市が実際にレポートに表示されることをプログラムで確認して、結果を検証できます。また、ツールにはさまざまなコストがかかります。人口とタイムゾーンのルックアップはインメモリの辞書読み取りですが、都市ごとの要約と最終集計はそれぞれLLMを呼び出します。これにより、管理すべき現実的な予算の圧力がかかります。

再現性のために、ルックアップツールは小さなモックされた辞書、CITY_FACTSから読み取るため、ノートブックはネットワークアクセスなしで完全に再現可能です。LLMバックエンドのピースは、実際のAnthropicモデルまたは決定論的なモックのいずれかで実行できます。これが最初のプリミティブにつながります。

プラグ可能なブレイン

これから構築するすべてのコンポーネントは、最終的にLLMを呼び出します。プランナー、サマライザー、アグリゲーター、クリティックです。その呼び出しが1つのSDKにハードワイヤードされている場合、ハーネス全体はテスト不可能になり、ベンダーロックインされます。

したがって、他のすべてに先立って、さまざまなLLM呼び出しAPIの詳細に対する抽象化を提供する基本クラスを定義します。

class LLMProvider:
    """共有インターフェース。異なるバックエンドをプラグインするにはサブクラス化します。"""

    def complete(self, system: str, user: str, role: str = “default”) -> str:
        raise NotImplementedError

    async def acomplete(self, system: str, user: str, role: str = “default”) -> str:
        # 同期呼び出しをスレッドでラップします。任意のSDKで機能します。
        return await asyncio.to_thread(self.complete, system, user, role)

また、テストとデバッグの目的で、決定論的でロールを認識した応答を返すMockProviderを実装します。計画を求められたときに標準的な計画、要約を求められたときにテンプレート化された1行の要約、判断を求められたときにルールベースの合格/不合格の判定を返します。これにより、開発中に「オーケストレーションが間違っているか?」と「モデルの計画が悪いか?」を分離できます。そして、この記事のすべての実験がどのマシンでも再現可能である理由です。

型付きツール

基本的なハーネスでは、ツール引数を手動で検証していましたが、このアプローチはすぐに崩壊します。新しいツールごとに検証ロジックが重複し、LLMは正式なスキーマを見ることはなく、引数の形状を推測するだけで、結果のエラーはモデルが自己修正できないアドホックな文字列になります。

アップグレードは、各ツールの引数をPydanticモデルとして宣言し、1つの定義がすべてを駆動するようにすることです。

@dataclass
class TypedTool:
    name: str
    description: str
    args_model: type[BaseModel]     # 引数スキーマを定義するPydanticモデル
    fn: Callable[..., Any]
    cost_hint: float = 0.0          # 予算会計の相対コスト

    def schema(self) -> dict:
        """Anthropic/OpenAIツール使用APIが期待する形状。"""

        return {
            "name": self.name,
            "description": self.description,
            "input_schema": self.args_model.model_json_schema(),
        }

    def run(self, raw_args: dict) -> Any:
        args, err = self.validate_args(raw_args)

        if err is not None:
            raise ValueError(err)
        return self.fn(**args.model_dump())

このアプローチにより、実行時検証、AnthropicおよびOpenAIのツール使用APIが期待する形状のJSONスキーマ、ドキュメント(Field(…, description =…)は、プランナーが読み取るカタログの一部になります)、そしてcost_hintを介したコスト会計のフックが得られます。実行前**の失敗により、潜在的な副作用を持つ高価なツール呼び出しを回避できます。悪い計画は、検証レイヤーですぐに失敗し、データベースクエリの奥深くで失敗するべきではありません。このアプローチは、LangChainツール、Anthropicツール使用、およびOpenAI関数呼び出しのような完全なフレームワークが収束するものと同様です。

私たちのレジストリには、3つのコストティアを持つ4つのツールがあります。get_populationとget_timezone()は実質的に無料の辞書ルックアップ(cost_hint =0.1)です。summarize_city()は都市ごとに1回のLLM呼び出し(cost_hint =1.0)を行い、aggregate_report()は最終的なMarkdownを生成するトークンを大量に消費する合成呼び出し(cost_hint =2.0)を行います。最後の2つは内部でLLMを呼び出すツールであることに注意してください。LLMは他のツールと同じです。ワーカーは均一なツールインターフェースを見ますが、一部のツールはサブプロンプトのラッパーであるため、ハーネスとは独立してキャッシュ、レート制限、または内部モデルをスワップできます。

プランはグラフ

基本的なハーネスは1ターンに1つのアクションを実行しました。これはステップが厳密に逐次的である場合には機能しますが、私たちのタスクには、単一の集計にフィードする9つの独立したルックアップがあります。

[画像]

whileループはこれらを一度に1つずつ実行します。有向非巡回グラフ(Directed Acyclic Graph)は依存関係を明示的に表現し、実行可能なすべてをすぐに並行して実行できるエグゼキューターを許可します。したがって、LLMに一度に1つのアクションを要求する代わりに、事前にグラフ全体をプランナーに要求します。LLMは実行する前に構造を宣言します。プランナーはLLMであるため、構造を幻覚させることもできます。存在しないノードIDへの依存関係や、決して完了できない循環依存関係などです。したがって、プランに対して最初に行うことは、壊れたプランを実行しようとトークンを無駄にする前に、それを検証することです。

def ready_nodes(self) -> list[PlanNode]:
    """依存関係がすべて完了しており、それ自体が保留中のノード。"""

    out = []
    for n in self.nodes.values():
        if n.status != NodeStatus.PENDING:
            continue

        if all(self.nodes[d].status == NodeStatus.DONE for d in n.deps):
            out.append(n)

    return out

ready_nodes()はスケジューラーの心臓部です。いつでも、依存関係がすべて満たされているノードのセットを返します。3都市の目標の場合、プランナーは10個のノードを出力します。依存関係リストが空の9つのフェッチ、すべて並行して実行可能、そして9つすべてに依存する1つのaggregate_reportキャップストーンノードです。

DAGの並列実行

エグゼキューターはレベル同期DAGウォーカーです。準備完了セットを計算し、asyncio.gatherで準備完了ノードをすべて起動し、それぞれを完了または失敗としてマークし、何も残っていないか、または進捗がないまで繰り返します。

MAX_CONCURRENT = 5  # 同時ツール/LLM呼び出しの上限

async def execute_dag(dag, tools, on_step=None):
    semaphore = asyncio.Semaphore(MAX_CONCURRENT)

    async def run_node(node):
        node.status = NodeStatus.RUNNING

        async with semaphore:
            try:
                # 同期ツールはスレッドプールで実行されるため、他のノードは続行できます
                node.result = await asyncio.to_thread(tools[node.tool].run, node.args)
                node.status = NodeStatus.DONE

            except Exception as exc:
                node.error = f”{type(exc).__name__}: {exc}”
                node.status = NodeStatus.FAILED

    while not dag.is_done():
        ready = dag.ready_nodes()

        if not ready:
            break  # 残りのノードは失敗した祖先に依存しています

        await asyncio.gather(*(run_node(n) for n in ready))

2つの小さな決定がここで大部分の重みを運びます。第一に、asyncio.to_threadは同期ツール関数をスレッドプールで実行します。これは、ツールをasync defに書き直したり、ハーネスを非同期ネイティブSDKに結合したりする必要がないことを意味します。第二に、セマフォは同時実行を制限します。それがない場合、50ノードのプランは50の同時LLM呼び出しを生成し、すぐにレート制限またはコストの急増に達します。これは、ワークスティーリングや優先度キューを備えた完全な動的スケジューラーではありません。私たちのエージェントワークロードのように、各ノードが数百ミリ秒から数秒かかるAPI呼び出しである場合、レベル同期並列処理はほとんどの利点を捉えます。逐次実行では、壁時計時間はほぼフェッチ遅延の合計です。並列実行では、それはほぼそれらの最大値に集計ステップを加えたものです。

正しいことを記憶する

ナイーブなエージェントはすべてをプロンプトにダンプします。完全なチャット履歴、すべてのツール出力、すべての以前のタスクです。これは二重に失敗します。使用しないトークンに対して支払い、無関係なテキストが目標を希釈すると、モデルのパフォーマンスは測定可能に低下します。プロダクションエージェントは代わりに、認知科学からゆるやかに着想を得た階層化メモリを使用します。ワーキングメモリは、常にコンテキスト内にあるスクラッチパッドです。現在の目標、プランの概要、および最後の数回の結果です。エピソードメモリは過去の実行の結果を保存し、過去のタスクが現在のタスクに似ている場合に取得されます。セマンティックメモリは背景事実を保持し、同じ方法で取得されますが、特定の実行には結び付けられません。

すべてを注入することはありません。現在の目標との類似性に基づいてトップkメモリを取得し、ハード文字予算の下でコンテキストを組み立てます。

def build_context(working: WorkingMemory, store: MemoryStore,
                  budget_chars: int = 4000) -> str:
    """ワーキングメモリと取得したメモリを組み立て、文字予算を尊重します。"""

    pieces = [working.to_prompt()]
    used = len(pieces[0])

    # エピソード(過去の類似タスク)を先に、次にセマンティック(事実)
    for kind in (”episodic”, “semantic”):
        for m in store.retrieve(working.goal, k=3, kind=kind):
            snippet = f”[{kind}] {m.content}”

            if used + len(snippet) + 1 > budget_chars:
                return “
”.join(pieces) + “
(...truncated at budget...)”

            pieces.append(snippet)
            used += len(snippet) + 1

    return “
”.join(pieces)

エピソードメモリはセマンティックメモリよりも優先されます。なぜなら、類似タスクでの過去の間違いは、一般的な事実よりも通常は対処しやすく、予算が尽きた場合、切り捨てはサイレントではなく明示的だからです。コンテキストは受動的に蓄積されるのではなく、能動的に組み立てられるべきです。

類似性関数自体については、ストアは2つのバックエンドをサポートします。ジャカード類似度は無料であり、教育には十分ですが、言い換えには失敗します。「フランスの有名なランドマーク」は、「パリはエッフェル塔で知られている」とはほとんど単語を共有しません。384次元ベクトルを使用した実際の文埋め込み(all-MiniLM-L6-v2によって生成)は、言い換えを近くのベクトルにマッピングします。私たちのMemoryStoreは、モデルが利用できない場合にジャカードをバックアップとして、まず埋め込みを試みます。このアップグレードの効果を定量化するには、適切なベンチマークが必要であり、これは将来の記事で実行します。

信頼し、検証する

エージェントは流暢で自信に満ちた、間違った出力を生成します。検証なしでは、都市をサイレントにドロップしたレポートがユーザーに出荷され、人間が偶然出力に目を通すまでリグレッションは気づかれません。しかし、すべてのチェックのコストは同じではなく、階層として配置します。実質的に無料の決定論的な構造チェックと、実際のトークンを消費する主観的な品質のためのLLMジャッジです。ルールは、常に安価なティアを最初に実行し、生き残ったものだけをエスカレートすることです。

def verify_report(report, goal, required_cities, provider) -> Verdict:
    det = deterministic_check_report(report, required_cities)

    if not det.passed:
        return det                # 安価なティアが検出しました — LLMを煩わせないでください

    # 決定論的に合格 → 主観的な品質のためにLLMジャッジにエスカレート
    return llm_judge_report(report, goal, provider)

意図的に不完全なレポート(たとえば、3都市が要求されたのにパリのみ)をこれにフィードすると、決定論的なティアでreason=「欠落している都市:[’東京’, ‘ニューヨーク’]
」で失敗します。ジャッジにトークンは1つも費やされず、理由文字列はリプランナーまたは人間が何が間違っていたかを正確に見ることができるほど実行可能です。この2ティアゲートは、ほとんどのプロダクション評価パイプラインの背後にある堅牢なパターンです。まず安価なフィルター、次に生き残ったものに高価なジャッジのみ。階層と同じくらい重要なのは、その背後にある関心の分離です。ワーカーが生成し、クリティックが評価するため、ジェネレーターは自分の宿題を採点することはありません。

クルーに会う:プランナー、ワーカー、クリティック

計画、実行、要約、自己批評を行う単一のプロンプトは、目的を混乱させがちです(計画の制約が執筆スタイルに影響する)そして、「計画部分」を分離することができず、テストとスワップの両方を複雑にします。

作業を狭いエージェントに分割し、それぞれに短いシステムプロンプトと単一の契約を与えます。プランナーは目標とツールスキーマを受け取り、DAG JSONを返します。これを実行前に検証します。ワーカーはDAGを受け取り、それを実行するだけです。クリティックは目標と完成したレポートを受け取り、判定を返します。プランナーのシステムプロンプトには、ライブツールカタログが直接スプライスされているため、実際に存在するツールのみを参照できます。

PLANNER_SYSTEM = """あなたはプランナーエージェントです。GOALが与えられたら、それを満たすツール呼び出しの依存関係グラフを生成してください。

この形状のJSONのみを出力してください(プロセやマークダウンなし):

{”nodes”: [{”id”: “...”, “tool”: “...”, “args”: {...}, “deps”: [...]}, ...]}

ノードは、`deps`が空であるか、すでに満たされている場合、並列で実行できます。
最終的なaggregate_reportノードは、すべてのアップストリームフェッチ/サマリーノードに依存する必要があります。
そのキャップストーンノードには、id「aggregate」を優先してください(任意のユニークなidが許容されます)。
利用可能なツール(名前とスキーマ):

<<TOOLS_JSON>>
"""

プランナーの背後に実際のモデルがあると、プランは構造的に有効ですが、スタイルは多様になり、オーケストレーターが後で見つける必要がある1つのノードを特定することは、クリーンアップコードよりもプロンプトでずっと安価です。

[画像]

これは、AutoGPTスタイルのプランナー、SWE-agentワーカー、またはLLMとしてのジャッジ評価者のようなプロダクションシステムが実際に行っていることを反映していますが、1回のセッションで読めるほどミニマルな状態を保っています。そして、3つの役割すべてが同じLLMProvider.complete(…, role =…)インターフェースを通過するため、プランナーモデルのスワップやクリティックのモックは1行の変更で済みます。

燃料ゲージと障害モード

基本的なハーネスには単一のmax_stepsカウンターがありましたが、これは実際の制約を隠していました。ステップは残っていてもトークンが残っていない、トークン予算内でもツール呼び出しでレート制限されている、またはハングしたネットワーク呼び出しがカウンターをインクリメントせずに壁時計時間を消費している可能性があります。BudgetMultiは、トークン、ツール呼び出し、壁時計時間、および推定ドルを同時に追跡し、いずれかの次元が枯渇すると実行が停止します。その最も有用な出力は単一のスカラーです。

def pressure(self) -> float:

    return max(
        self.tokens_used / self.max_tokens,
        self.tool_calls_used / self.max_tool_calls,
        self.elapsed() / self.max_wall_seconds,
        self.cost_usd / self.max_cost_usd,
    )

プレッシャーは、すべての次元にわたる最大利用率です。実際の請求と同様に、最初に枯渇したリソースによって制限されます。その1つの数値が段階的な劣化を促進します。0.7未満では、LLMジャッジを含む完全なパイプラインが実行されます。0.9を超えると、オーケストレーターは高価なクリティックをスキップし、決定論的なチェックのみにフォールバックします。1.0では、実行は部分的な結果で停止します。プロダクションエージェントは、同じ種類のシグナルを使用して、より安価なモデルに切り替えたり、検索深度を減らしたり、ユーザーに確認を求めたりします。

運用上の健全性のもう半分は、すべてのエラーが同じ応答に値するわけではないことを認識することです。レート制限またはタイムアウトは、指数関数的バックオフ(ジッター付き、これによりエージェントのフリートが同期して再試行しないようにします)と再試行で一時的です。検証エラーはツールの誤用であり、構造化されたエラーをLLMにフィードして引数を修正できるようにします。未知のエンティティは情報不足であり、再試行は積極的に有害です。なぜなら、幻覚された都市名を再試行しても毎回同じように失敗するからです。正しい行動は、それを除外して再計画することです。そして、ポリシー違反は致命的であり、すぐに停止する必要があります。小さなclassify_error()関数は、エラー文字列をこれらの4つのクラスにマッピングし、回復ポリシーは、盲目的な再試行からではなく、クラスから導き出されます。

フライトレコーダー

エージェントが失敗した場合、何が、どの順序で発生したか、各ステップにどれくらいの時間がかかったか、どの役割がトークンを消費したか、そして物事が悪化する前に予算圧力が上昇していたかどうかを回答できる、変更不可能な構造化イベントのログが必要です。私たちのTracerのすべてのイベントは、ID(ステップIDと、ワーカーステップを生成したプランにリンクする親ID)、セマンティクス(役割と実行されたアクション)、経済性(レイテンシ、トークン、コスト、および書き込み時の予算圧力のスナップショット)、そしてクリティックイベントの場合は判定をキャプチャします。スキーマはフラットで退屈です。JSONシリアライズ可能な辞書のリストであり、ファイルをダンプしたり、OpenTelemetryまたはLangSmithに送信したり、matplotlibで直接プロットしたりできます。実際のオブザーバビリティを得るために独自のフォーマットは必要ありません。十分なスキーマがあれば十分です。

役割別に色分けされたステップごとのレイテンシは、summarize_city()とaggregate_report()ノードが壁時計時間を支配し、ルックアップはフラットであることをすぐに示します。LLM呼び出しが秒を消費する場所であり、それらを並列で実行することが重要な理由です。

[画像]役割別のステップごとのレイテンシ

予算圧力は、集計時に急増しながら単調に上昇し、クリティックが実行される前に0.9の劣化しきい値を超えた場合、トレース自体がLLMジャッジがスキップされた理由を説明します。

[画像]

最後に、役割別のトークンは、計画または実行のどちらが予算を消費しているかを示します。このタスクでは、多くのサマリー呼び出しがあるワーカーに大きく偏っています。

[画像]役割別のトークン使用量。このタスクではワーカーが支配的です。

すべてをまとめる

プリミティブが配置されると、Orchestratorはほとんど退屈になります。メモリからコンテキストを構築し、プランナーにDAGを要求し、DAGをワーカーに渡します。各ツール呼び出しでトレースイベントを記録し、予算を請求するコールバックを使用します。失敗を確認し、圧力認識型の劣化で結果を検証し、結果をエピソードメモリに保存して将来の実行に備え、レポート、判定、DAG、トレース、および予算をバンドルしたRunResultを返します。追加される唯一の新しい動作は、再計画ループです。実行が失敗し、エラーが情報不足に分類された場合、盲目的に再試行するのではなく、失敗コンテキストをプランナーに送信します。これは、設定可能なmax_replansまでです。

メソッドの心臓部は数行で収まります。

for attempt in range(self._max_replans + 1):
    dag = self.planner.plan(goal) if attempt == 0 else self.planner.replan(goal, dag)

    await self.worker.execute(dag, on_step=on_step)

    if dag.any_failed():
        failed = (n for n in dag.nodes.values() if n.status == NodeStatus.FAILED)

        if any(classify_error(n.error or “”) == ErrorClass.MISSING_INFO for n in failed) \
                and attempt < self._max_replans and budget.has_room():
            continue          # 情報に基づいた再計画、盲目的な再試行ではない

        return RunResult(..., status=”failed_execute”)
    break                     # 成功

# 圧力認識型の劣化:予算がタイトな場合はLLMジャッジをスキップ
if budget.pressure() > 0.9:
    verdict = deterministic_check_report(report, required_cities)
else:
    verdict = self.critic.judge(report, goal, required_cities)

モックプランナーは常にキャップストーンノードをaggregateと名付け、オーケストレーターの初期バージョンは単にそのidでルックアップしていました。実際のモデルに切り替えると、その仮定は静かに壊れます。プランナーはしばしばツール名aggregate_reportをミラーリングしたり、独自のidを考案したりして、構造的には有効ですが、モックが私たちに期待するように訓練したものではないプランを生成します。修正は二重です。DAGは、idではなくツールによってキャップストーンを解決するようになりました(dag.aggregate_node()はユニークなaggregate_reportノードを返します。そして、複数のノードを含むプランを拒否します)。そして、プランナープロンプトには、先ほど見た明示的なキャップストーンの指示が追加されました。LLMの言葉を鵜呑みにしないでください。ノード名についても同様です。

まだ欠けているもの

基本的なハーネスとこの高度なハーネスの間で、成功するカスタムハーネスを構築するために必要なすべての主要な概念とアイデアをほぼカバーしました。前の投稿の約35行のループに、7つのプロダクション形状のプリミティブをレイヤー化しました。1つのスキーマから検証とLLMのイントロスペクションを提供する型付きツール、単一のツールを書き直すことなく並列処理を購入するDAGエグゼキューター、ハード予算の下で関連コンテキストを組み立てる階層化メモリ、安価なチェックを生き残った出力にのみトークンを費やす検証階層、独立してテストおよびスワップできる狭いプランナー/ワーカー/クリティックの役割、クラッシュするのではなく段階的に劣化するマルチディメンションの予算、そして実行を実行可能な実験に変えるトレーサー(逸話ではなく)。

これらのピースのどれも他のピースを必要としませんが、それらは構成されます。レジストリにツールを追加すると、プランナーは自動的にそのスキーマを認識します。verify_report()を締めると、将来のすべての実行が新しいバーに準拠します。LLMバックエンド全体をスワップすると、ハーネスは変更されずに再実行されます。コンポジビリティは、PoCと拡張可能なハーネスの違いであり、オーケストレーターが薄いままであった理由です。

いくつかの注意点があります。メモリはインプロセスですが、プロダクションシステムは埋め込みをChroma、Weaviate、またはpgvectorに永続化します。ツール出力は命令として信頼されますが、プロダクションシステムはそれらをプロンプトインジェクションに対してデータとしてサンドボックス化する必要があります。元に戻せないアクションは人間の承認を必要とします。そして、私たちのトークンアカウンティングは、実際のシステムがSDKから使用状況メタデータを読み取るのに対し、文字数から推定します。これらそれぞれは、さらに1つのコンポジショナルレイヤー先にあります。まさにそれがポイントです。

1つの意図的な省略もあります。単一の成功したデモは、ハーネスが機能することを示しますが、この記事のどれも、それがほとんどの場合に実際に機能することを示していません。それは評価ハーネスの仕事であり、将来のフォローアップ記事で取り上げます。