<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0"><channel><title><![CDATA[konippi]]></title><description><![CDATA[I write about building software with AI agents and designing the agents themselves.]]></description><link>https://konippi.hashnode.dev</link><generator>RSS for Node</generator><lastBuildDate>Sat, 21 Nov 2026 15:46:26 GMT</lastBuildDate><atom:link href="https://konippi.hashnode.dev/rss.xml" rel="self" type="application/rss+xml"/><language><![CDATA[en]]></language><ttl>60</ttl><item><title><![CDATA[Understanding Personal Agent Protocol]]></title><description><![CDATA[AI エージェントがユーザーの代わりに企業のサイトや API を使うとき、企業はどのエージェントが、誰の代理で、何を許可されているのかをどこまで確かめられるのか。Personal Agent Protocol (Poppy) v1.0 の仕組みを整理します。]]></description><link>https://konippi.hashnode.dev/understanding-personal-agent-protocol</link><guid isPermaLink="true">https://konippi.hashnode.dev/understanding-personal-agent-protocol</guid><category><![CDATA[AI]]></category><category><![CDATA[ai agents]]></category><category><![CDATA[oauth]]></category><category><![CDATA[protocols]]></category><category><![CDATA[personal-agent-protocol]]></category><category><![CDATA[poppy]]></category><dc:creator><![CDATA[Kyosuke Konishi]]></dc:creator><pubDate>Sun, 15 Nov 2026 05:29:09 GMT</pubDate><enclosure url="https://cdn.hashnode.com/uploads/covers/6ac08dc1e458e2a1f27e88e5/e1ae1d9e-5d27-49da-b82d-557a2d52338b.png" length="0" type="image/jpeg"/><content:encoded><![CDATA[<p>ユーザーの代わりに予約や買い物、問い合わせをこなすパーソナル AI エージェントが増えています。たとえば Meta の AI エージェント Muse は、企業のサイトで買い物をし、サポートへの問い合わせまで済ませます。</p>
<p>ところが、企業の側にはエージェントを受け入れる仕組みがありません。アクセスしてきたのが本人なのか、本人に頼まれたエージェントなのか、不正なボットなのかを見分けられず、エージェントをまとめてブロックする企業も出てきました。</p>
<p>この問題に対して Sierra と Meta が 2026 年 10 月に提案したのが <a href="https://personalagentprotocol.org/">Personal Agent Protocol</a> (通称 Poppy) で、11 月 13 日に <a href="https://sierra.ai/blog/releasing-poppy">v1.0 がリリース</a>されました。リリースに合わせて Shopify は全加盟店で Poppy を有効にし、Muse も全ユーザーを対象に、訪れたサイトでまず Poppy を探すようになりました。デザインパートナーは 100 社を超えています。</p>
<p>先に結論を書いておきます。このプロトコルを使うと、企業はどのエージェントが、何を許されてアクセスしてきたのかを確かめられます。しかし、それが誰の代理なのか、ユーザーが本当にその操作を頼んだのかは、エージェントの申告を信じるしかありません。企業にできるのは、問題を起こしたエージェントを後から見分けて、そのエージェントだけを制限したり拒否したりすることです。申告の偽りや権限の乱用を、未然に防ぐ仕組みではありません。</p>
<p>本記事では、企業がプロトコルで何を確かめられるのかに注目して、仕組みを見ていきます。内容は執筆時点の<a href="https://personalagentprotocol.org/docs/1.0/spec">仕様 v1.0</a> に基づいています。</p>
<h2>1. 任せきるか、ブロックするか</h2>
<p>現在のエージェントには、ユーザーのパスワードでサインインして本人として振る舞うか、企業にブロックされて何もできないかの二択しかありません。パスワードを渡してしまえば、ユーザーはエージェントに何をさせるかを制限できませんし、企業はエージェントと人間を区別できません。このままエージェントにできることが増えれば、企業は検知を強め、エージェントはそれをかいくぐろうとする、いたちごっこが続きます。</p>
<p>Personal Agent Protocol は、この二択の間に段階を設けようとしています。たとえば航空会社なら、フライトの検索はどのエージェントにも許し、旅程の閲覧はサインインしたエージェントだけに認め、航空券の購入にはユーザーの承認を求める、といった設計ができます。ユーザーも、旅程は見せてよいが変更はさせない、と決められます。</p>
<img src="https://cdn.hashnode.com/uploads/covers/6ac08dc1e458e2a1f27e88e5/10a8eab6-30f9-4524-a137-397a7498b9bf.png" alt="All or nothing versus points in between" style="display:block;margin:0 auto" />

<em>二択の現状と、Personal Agent Protocol が作る中間の段階</em>

<p>Sierra は<a href="https://sierra.ai/blog/introducing-personal-agent-protocol">公式ブログ</a>で、「エージェントにどこまでアクセスさせるかはユーザーが決め、何ができるかの範囲は企業が決める」という役割分担を原則に挙げています。Muse を運営する Meta も<a href="https://www.facebook.com/business/news/a-new-way-for-businesses-and-personal-agents-to-work-together">ブログ</a>で、負荷の急増や不正利用を心配する企業の立場に理解を示しながら、「エージェントを追い返せば、その背後にいる顧客も追い返すことになる」と書いています。</p>
<h2>2. Personal Agent Protocol の全体像</h2>
<p>Personal Agent Protocol に登場するのは以下の 3 者です。</p>
<ul>
<li><strong>ユーザー</strong>: パーソナル AI エージェントに作業を任せる人</li>
<li><strong>パーソナル AI エージェント</strong>: ユーザーの代わりに企業とやり取りするソフトウェア (例: Muse)</li>
<li><strong>企業</strong>: プロトコルを実装し、エージェントを受け入れる側</li>
</ul>
<img src="https://cdn.hashnode.com/uploads/covers/6ac08dc1e458e2a1f27e88e5/1f1edeff-f787-45ef-8065-6e62baaaff25.png" alt="Personal Agent Protocol overview" style="display:block;margin:0 auto" />

<em>Personal Agent Protocol の全体像</em>

<p>起点は、企業が <code>https://{domain}/.well-known/poppy.json</code> に置く JSON です。エージェントはまずこれを読み、その企業が何を提供しているかを把握します。</p>
<pre><code class="language-json">{
  "protocol_version": "1.0",
  "organization": { "name": "Example Company", "domain": "example.com" },
  "auth": {
    "scopes": {
      "orders:read": "See your orders, returns, and bookings. Needed to track an order or find one to change",
      "orders:write": "Exchange or return items, and change bookings. Needed for any change to an order"
    },
    "scope_hints": {
      "orders:read": { "changes": "none", "personal_data": true },
      "orders:write": { "changes": "irreversible", "personal_data": true }
    }
  },
  "agent": {
    "protocols": [{
      "type": "poppy",
      "endpoint": "https://api.example.com/poppy/conversations",
      "description": "Anything about your orders, returns, account, and our products"
    }]
  },
  "web": { "browser_session_endpoint": "https://example.com/poppy/browser-session" },
  "tasks": { "endpoint": "https://api.example.com/poppy/tasks" },
  "apis": [
    { "type": "openapi", "url": "https://api.example.com/openapi.json", "description": "Orders, returns, and exchanges" },
    { "type": "mcp", "url": "https://mcp.example.com/mcp", "description": "Product search and sizing" }
  ]
}
</code></pre>
<p><code>auth</code> には、企業が定義したスコープとその説明が入ります。サインインの方法はここには書かれておらず、エージェントは企業の認可サーバーが公開するメタデータ (例: <code>https://auth.example.com/.well-known/oauth-authorization-server</code>) から読み取ります。<code>agent</code>、<code>web</code>、<code>apis</code> は、エージェントが企業とやり取りする 3 つの経路で、順に企業側の AI エージェント (Company Agent) との会話、Web サイト、API にあたります。<code>tasks</code> は、プロトコルで提供していないタスクの一覧やエージェント向けのスキル、フィードバックの窓口を返すエンドポイントです。</p>
<p>仕様の例をもとに、ユーザーが「注文したジャケットが寒いので、暖かいものに替えたい」と頼んだときの流れを追ってみます。</p>
<ol>
<li>エージェントは企業の <code>poppy.json</code> を読み、会話や API の場所を知る</li>
<li>サインインしないまま、Company Agent に「同じジャケットの暖かいモデルに M サイズはあるか」と尋ねる</li>
<li>交換には注文の情報が必要なので、ユーザーが企業のページでサインインし、注文の閲覧と変更を許可する</li>
<li>エージェントが交換の API を呼ぶと、企業は実行せずに「差額 70 ドルで交換する」という条件を返す</li>
<li>エージェントがユーザーに条件を見せて承認をもらい、それを付けて同じリクエストを送り直すと、企業が交換を実行する</li>
</ol>
<p>v1.0 では、アカウントへのアクセスに標準の OAuth を使います。トークンも OAuth のアクセストークンとリフレッシュトークンなので、必要な標準に対応していれば、企業は既存の認可サーバーを使えます。プロトコルが OAuth に<a href="https://personalagentprotocol.org/docs/1.0/spec#oauth-additions">追加したもの</a>は、OAuth より厳しいいくつかの規定と、企業が何を提供しているかを公開する <code>poppy.json</code>、すべてのリクエストに付くセッションヘッダー、Web サイトや API、会話でのやり取りの方法、タスクの案内、拡張です。</p>
<h2>3. 企業の問いにどう答えるか</h2>
<p>エージェントからリクエストが届いたとき、企業が知りたいのは以下の 5 つです。この章では、それぞれに仕様がどう答えているかを見ていきます。</p>
<ol>
<li>どのエージェントか</li>
<li>誰の代理か</li>
<li>何が許可されているか</li>
<li>どのセッションか</li>
<li>本人が頼んだ操作か</li>
</ol>
<h3>どのエージェントか</h3>
<p>エージェントは、事前登録で発行された ID ではなく、以下のようなメタデータを置いた URL を <code>client_id</code> として名乗ります。</p>
<pre><code class="language-json">{
  "client_id": "https://agent.example/agent.json",
  "client_name": "Example Agent",
  "jwks_uri": "https://agent.example/jwks.json",
  "redirect_uris": ["https://agent.example/oauth/callback"],
  "token_endpoint_auth_method": "private_key_jwt"
}
</code></pre>
<p>企業はこのメタデータを取得して、エージェントの名前と公開鍵の場所 (<code>jwks_uri</code>) を知ります。公開鍵は <code>client_id</code> と同じドメインに置く決まりなので、エージェントは対応する秘密鍵で署名した JWT を送ることで、その <code>client_id</code> のエージェントとして認証されます。この方式は IETF で策定中の <a href="https://datatracker.ietf.org/doc/draft-ietf-oauth-client-id-metadata-document/">OAuth Client ID Metadata Document</a> (CIMD) に沿ったもので、MCP の認可仕様にも採用されています。</p>
<p><code>jwks_uri</code> の鍵がリクエストに直接署名するのは、認可サーバーでのクライアント認証だけです。毎回のリクエストに付くセッションヘッダーには、この鍵が保証した有効期限 24 時間以内の鍵を、User ID ごとに使い分けて署名します。漏れた鍵を悪用できるのは有効期限までで、別の User ID に署名した鍵を企業が拒否すれば、被害を 1 人に絞れます。既存のボット対策向けには、<a href="https://datatracker.ietf.org/doc/draft-ietf-webbotauth-httpsig-protocol/">Web Bot Auth</a> によるエージェント運営者の署名も推奨されています。</p>
<p>仕様は、<code>jwks_uri</code> の鍵での署名に RSA の<a href="https://www.rfc-editor.org/rfc/rfc9474">ブラインド署名</a>を使うことも推奨しています。エージェント運営者はユーザーの端末が作った JWT に中身を見ずに署名するので、ユーザーがどの企業を使っているかを知りません。その代わり、どのユーザーの端末もエージェントの正規の署名を得られるので、運営者は署名を通じて特定のユーザーを止められません。</p>
<p>企業は <code>client_id</code> ごとに許可リストや拒否リスト、レート制限を設定でき、不正利用があればその <code>client_id</code> を無効にできます。</p>
<h3>誰の代理か</h3>
<p>エージェントは、企業の API や会話へのリクエストすべてにセッションヘッダー (<code>Poppy-Session</code>) を付けます。中身はリクエストごとに署名する JWT で、以下のようにセッション ID (<code>sid</code>)、User ID (<code>sub</code>)、リクエストのメソッドと URL、サインイン後はアクセストークンのハッシュ (<code>ath</code>) を含みます。セッションを開始するための手順は特になく、新しい <code>sid</code> を付けた最初のリクエストがそのままセッションの始まりになります。</p>
<pre><code class="language-json">{
  "iss": "https://agent.example/agent.json",
  "aud": "https://auth.example.com",
  "sid": "Yx2b7Qd_Kp8mR3vT1nWc4A",
  "sub": "usr_Q7c1vK",
  "htm": "POST",
  "htu": "https://api.example.com/orders/ord_7Hk2/exchanges",
  "iat": 1790900000,
  "jti": "e1j3V_bKic8-LAEBq7Rw2g",
  "ath": "fUHyO2r2Z3DZ53EsNrWBb0xWXoaNy59IiKCAqksmQEo"
}
</code></pre>
<p>User ID は、エージェントがユーザーと企業の組ごとに割り当てる ID です。企業は再訪したユーザーを識別できますが、ID は個人情報と無関係なので誰かは分からず、企業ごとに異なるので他社と突き合わせることもできません。ただし、サインインするとそれまでの訪問がアカウントに結び付くため、サインインしない閲覧には使い捨ての User ID も使えます。</p>
<img src="https://cdn.hashnode.com/uploads/covers/6ac08dc1e458e2a1f27e88e5/a6b3176a-4b12-4b9b-89b4-d0a9930b5634.png" alt="From discovery to a signed-in session" style="display:block;margin:0 auto" />

<em>Discovery からサインインまでの流れ</em>

<h3>何が許可されているか</h3>
<p>タスクにアカウントが必要になった時点で、ユーザーがサインインします。使うのは標準の OAuth で、方法は 2 つあります。Direct Sign-In (認可コードフローと PKCE) では、ユーザーが自分のブラウザで企業のページを開いて許可します。Device Sign-In (Device Authorization Grant) では、エージェントが示したリンクとコードを使い、スマートフォンなど別の端末から許可します。仕様が推奨するのは Direct のほうです。Device は必ず別の端末で許可するため、他人が始めたサインインをユーザーに許可させるフィッシングに悪用されやすいからです。</p>
<p>何を許すかはスコープで表し、スコープは企業ごとに定義します。エージェントは企業が用意したスコープから必要なものを要求し、ユーザーはその中から許可するものを選びます。1 章で触れた役割分担は、この仕組みで実現されています。企業は API と Company Agent の両方でスコープを強制するので、エージェントは許された範囲を超えて操作できません。アクセストークンを <a href="https://www.rfc-editor.org/rfc/rfc9449">DPoP</a> でエージェントの鍵に結び付けるかどうかは企業が決めます。結び付けない場合でも、セッションヘッダーはトークンのハッシュを含めて署名されているので、企業がヘッダーを検証していれば、トークンだけを盗んでも使えません。ただし、ブラインド署名など、ユーザーの端末が署名を得られるエージェントでは、同じエージェントの別のユーザーがヘッダーを作れるので、DPoP でユーザーごとの鍵に結び付けると、この隙を狭められます。</p>
<p>スコープの範囲は強制できても、許可したのが本当にユーザー本人なのか、サインインを始めた人と同じ人なのかは、企業には分かりません。トークンはサインインを始めた側に渡り、誰が許可したかはどこにも示されないからです。同じエージェントの別のユーザーが始めたサインインでも、企業から見れば正規のリクエストです。</p>
<img src="https://cdn.hashnode.com/uploads/covers/6ac08dc1e458e2a1f27e88e5/3a82d660-ca22-44be-a1dd-202833b05f48.png" alt="Sign-in started by someone else" style="display:block;margin:0 auto" />

<em>他人が始めたサインインを、被害者が許可してしまう</em>

<p>仕様は、OAuth のクロスデバイスのフローと同じく、このリスクを<a href="https://personalagentprotocol.org/docs/1.0/spec#attacker-started-sign-in">受け入れています</a>。そのうえで、同意画面に「いまこのエージェントに頼んだ場合だけ続けてください」と書くことと、以前に許可したものも含めて付与するスコープをすべて表示することで、被害を抑えようとしています。求められた以上のスコープを付与してはならないという OAuth より厳しい規定があるのも、承認した人が見ていないスコープを渡さないためです。</p>
<h3>どのセッションか</h3>
<p>1 つのセッションは、Web サイト、API、会話の 3 つの経路で共有できます。2 章の例なら、サインイン前に Company Agent にした質問と、サインイン後に API で頼んだ交換を、企業は一連の利用として扱えます。3 つの経路をすべて用意する必要はなく、どれか 1 つから始めて、あとから追加することもできます。</p>
<img src="https://cdn.hashnode.com/uploads/covers/6ac08dc1e458e2a1f27e88e5/6ab3ae59-b507-46b9-846f-781f84e251cd.png" alt="One session across every channel" style="display:block;margin:0 auto" />

<em>1 つのセッションを 3 つの経路で共有する</em>

<p>Web サイトでは、エージェントが制御するブラウザをセッションに参加させます。ブラウザが企業のページからワンタイムコードを受け取り、エージェントがそのコードを自分のリクエストで認可すると、企業はブラウザにセッションの Cookie を発行します。アクセストークンはブラウザを通りません。</p>
<p>既存の Web サイトには、スコープを適用できないこともあります。その場合、企業は <code>web.unscoped</code> を宣言し、サインインしたブラウザには Web サイト上でアカウントができることすべてが許されることをスコープの説明に明記したうえで、ユーザーの許可を得ます。ブラウザから使われたくなければ <code>web.disabled</code> で意思を示せますが、強制はできません。ブラウザを操作しているのがエージェントか人間かを常に見分けられるわけではないと、仕様自身も認めています。</p>
<p>チェックインのように本人に操作してほしい手順があれば、企業は <a href="https://personalagentprotocol.org/docs/1.0/extensions/browser-control">Browser Control 拡張</a>でその手順に印を付け、エージェントからユーザーにブラウザの操作を渡してもらえます。もっとも、ページが読み取る「いま操作しているのは誰か」という値には署名がありません。仕様も、これを本人が操作した証拠として扱ってはならないとしています。</p>
<h3>本人が頼んだ操作か</h3>
<p>2 章の例の 4 と 5 は、<code>operations</code> <a href="https://personalagentprotocol.org/docs/1.0/extensions/operations">拡張</a>の仕組みです。交換や予約の変更、解約のように影響の大きい操作の前に、正確な条件に対する承認を取ります。企業はまずリクエストを実行せずに断り、以下のような操作 (operation) を返します。</p>
<pre><code class="language-json">{
  "operation_id": "exc_5Rt2",
  "revision": "1791487200-k3Jd9Qx2mW8v",
  "summary": "Exchange the Stormline Jacket (M) on order ord_7Hk2 for the Stormline Insulated Jacket (M), for $70.00 more, charged to the card used for the order.",
  "terms": {
    "order_id": "ord_7Hk2",
    "item_id": "itm_4Qa",
    "replacement_sku": "stormline-insulated-m",
    "price_difference": { "amount": "70.00", "currency": "USD" }
  },
  "expires_at": "2026-10-08T12:20:00-07:00"
}
</code></pre>
<p><code>summary</code> はユーザーがそれだけ読めば判断できる説明です。<code>terms</code> は同じ条件を JSON で表したもので、エージェントは頼んだ内容と一致するかをこれで確かめます。承認するのは、条件を見せられたユーザーか、「差額が 20 ドル未満の交換なら進めてよい」といったユーザーの指示を受けたエージェントです。</p>
<p>エージェントは承認を付けて同じリクエストを送り直し、企業は承認されたリビジョン (<code>revision</code>) と現在の条件が一致することを確かめてから実行します。条件が変わればリビジョンも変わり、承認はやり直しです。エージェントが指示に基づいて承認していた場合は、新しい条件をユーザーに確認しなければなりません。同じ承認で何度送り直しても、実行されるのは 1 回だけです。</p>
<p>承認が付いていても、企業は自分の判断で実行を断れます。その際、ユーザー向けの短い説明や代わりの方法は返せますが、理由コードは返しません。仕様によると、コードを返すと回避策の手がかりを与え、企業のリスク判定の基準も明かしてしまうからです。また、操作ごとに「ユーザー本人の承認」を必須にする仕組みは、承認者を企業が確かめられない以上は強制できないとして<a href="https://github.com/personal-agent-protocol/personal-agent-protocol/issues/78">見送られました</a>。</p>
<img src="https://cdn.hashnode.com/uploads/covers/6ac08dc1e458e2a1f27e88e5/31025d92-307e-4c55-a7fd-6f5b6d2fb6f0.png" alt="Operations flow" style="display:block;margin:0 auto" />

<em><code>operations</code> 拡張の流れ</em>

<h2>4. 企業が確かめられる範囲</h2>
<p>3 章の問いのうち、企業が確かめられるのは、どのエージェントか (署名)、何が許可されているか (スコープ)、どのセッションか (セッションヘッダーと Cookie) の 3 つです。</p>
<p>残る 2 つ、誰の代理か、本人が頼んだ操作かは、エージェントの申告を信じるしかありません。User ID はエージェントが割り当てた ID にすぎず、承認もエージェントが伝えてくるものだからです。仕様もこの限界を認めていて、本人がサインインしたかについては "A Company can't always verify this"、<code>operations</code> については "Accepting only user approvals still relies on the Personal Agent's statement, and doesn't show that the User approved." と述べています。そのため、本人の承認を確かめたい操作は <code>operations</code> で受け付けず、自社の Web サイトやアプリで本人に確認するよう勧めています。</p>
<img src="https://cdn.hashnode.com/uploads/covers/6ac08dc1e458e2a1f27e88e5/f02d0026-0e0b-446d-87d7-ce99161049db.png" alt="What the company can verify and what it has to trust" style="display:block;margin:0 auto" />

<em>企業が確かめられる範囲</em>

<p>許された範囲の中でどう振る舞うかも、プロトコルは定めていません。予約の権限を持つエージェントが予約枠を大量に押さえても、違反にはなりません。Meta は前述のブログで、誠実な人が手作業でするのと同じやり方と規模か、すべてのエージェントが同じことをしても仕組みが回るか、という 2 つのテストを公開していますが、これは Muse 自身の基準です。</p>
<p>そのため、企業にできるのは問題を起こしたエージェントを後から制限することです。User ID はエージェントがいくらでも作れるので、サインインしていないリクエストを確実に制限し、ブロックし、信頼できる単位は、エージェント (<code>client_id</code>) です。<a href="https://personalagentprotocol.org/docs/1.0/guides">ガイド</a>はレート制限を <code>client_id</code>、ユーザー、セッションのそれぞれでかけ、<code>client_id</code> の分は署名を検証してから数えるよう求めています。検証前に数えると、攻撃者が別のエージェントの <code>client_id</code> を名乗るだけで、そのエージェントの枠を使い切ってしまうことが可能だからです。</p>
<h2>5. 導入の始め方と、残された課題</h2>
<p>企業は、必要な機能だけを選んで導入できます。たとえば、サインインの要らない API なら OAuth サーバーなしで公開できます。再訪したユーザーを識別したいならセッションヘッダーを検証し、アカウントが必要なタスクには OAuth を使います。</p>
<p>プロトコルで提供していないタスクは、<code>tasks</code> で一覧にして代わりの方法を案内できます。エージェントの側も、こなせなかったタスクを企業に報告できます。この仕組みがないと、エージェントはありもしない方法を探し回ることになり、企業からは「顧客が去った」ことしか見えません。</p>
<p>業界ごとの機能は拡張として追加します。Sierra のブログで Shopify との共著と紹介されている commerce extension は、仕様では Universal Commerce Protocol (UCP) とつなぐ <a href="https://personalagentprotocol.org/docs/1.0/extensions/ucp">UCP 拡張</a>として公開されています。カートや決済といった買い物そのものは UCP に任せ、Poppy は <code>poppy.json</code> による案内、エージェントとユーザーの識別、サインインを受け持ちます。Shopify では、各ストアの <code>poppy.json</code> が自動で公開されています。</p>
<p>互換性の面では、v1.0 以降はマイナーバージョンが上がっても古いエージェントが動かなくなることはないとされています。企業は複数のバージョンを同時に提供することもできます。</p>
<p>まだ仕様にない機能は<a href="https://personalagentprotocol.org/docs/roadmap">ロードマップ</a>にまとめられており、以下の項目が挙がっています。</p>
<ul>
<li><strong>署名付きの承認</strong>: 取り消しにくい操作について、企業がユーザーの承認を自ら確かめられるようにする。企業のページでの承認、端末での署名、第三者による証明が提案されている</li>
<li><strong>決済</strong>: ユーザーが承認した内容に結び付いた支払い。UCP 拡張で決済はできるが、<code>operations</code> との組み合わせは未定</li>
<li><strong>プッシュ通知</strong>: 発送や担当者からの返信を、企業がエージェントに知らせる方法</li>
<li><strong>添付ファイル</strong>: レシート、返品ラベル、商品画像、ユーザーが記入するフォームなど</li>
<li><strong>セルフホストのエージェント</strong>: ユーザーの端末で動くエージェントや、ユーザー自身のブラウザでの操作</li>
</ul>
<h2>まとめ</h2>
<p>Personal Agent Protocol は、「任せきるか、ブロックするか」の二択の間に段階を作るためのプロトコルです。アカウントへのアクセスは標準の OAuth に任せ、そのうえでエージェントの身元と User ID を、セッションヘッダーですべてのリクエストに載せます。ユーザーが本当に頼んだのかはエージェントの申告に委ねられ、許された範囲でどう振る舞うかはプロトコルの外にあります。</p>
<p>この 2 点を物足りなく感じる人もいると思いますが、私は現実的な線の引き方だと考えています。ユーザーがエージェントの画面で何を見て何を承認したのかを、企業が外から確かめる標準的な方法が今のところないからです。それでも企業は、エージェントを一律にブロックせず、エージェントごとに制限をかけられるようになります。エージェントの側も、正規の経路で企業とやり取りできます。</p>
<p>今後の焦点は、この線をどこまで検証側に寄せられるかだと思います。ロードマップにある署名付きの承認が入れば、取り消しにくい操作に限っては企業がユーザーの承認を自分で確かめられるようになり、決済もその上に載せやすくなります。メンテナーは、そのためにはユーザーの端末での署名に加えて、端末側の対応か、企業が条件を表示する Web の仕組みが必要になるとみています。</p>
]]></content:encoded></item><item><title><![CDATA[Anatomy of a Software Factory]]></title><description><![CDATA[Software Factory に関する事例は、工程の構成がほとんど共通しています。違いは、どの工程をエージェントに任せ、どの工程に人間の判断を残すかです。本記事では、Software Factory を設計するときに何を決める必要があるのかを整理します。]]></description><link>https://konippi.hashnode.dev/anatomy-of-a-software-factory</link><guid isPermaLink="true">https://konippi.hashnode.dev/anatomy-of-a-software-factory</guid><category><![CDATA[AI]]></category><category><![CDATA[ai agents]]></category><category><![CDATA[software development]]></category><category><![CDATA[Software Engineering]]></category><dc:creator><![CDATA[Kyosuke Konishi]]></dc:creator><pubDate>Sun, 04 Oct 2026 23:34:14 GMT</pubDate><enclosure url="https://cdn.hashnode.com/uploads/covers/6ac08dc1e458e2a1f27e88e5/bea717d7-cbfe-447f-bb7f-f0e300ee0b96.jpg" length="0" type="image/jpeg"/><content:encoded><![CDATA[<p>2026 年に入り、「Software Factory」という言葉を目にする機会が増えました。<a href="https://www.ai.engineer/worldsfair/2026">AI Engineer World's Fair 2026</a> では Software Factory のトラックが設けられたほか、<a href="https://openai.com/index/harness-engineering/">OpenAI</a>、<a href="https://www.uber.com/gb/en/blog/efficient-software-factory/">Uber</a>、<a href="https://engineering.atspotify.com/2026/6/code-with-claude-coding-is-no-longer-the-constraint">Spotify</a>、<a href="https://shopify.engineering/under-the-river">Shopify</a>、<a href="https://vercel.com/blog/building-a-software-factory-for-ai-sdk">Vercel</a> はエージェントを組み込んだ開発の仕組みをブログで公開し、<a href="https://www.warp.dev/blog/a-guide-to-cloud-software-factories-for-engineering-leaders">Warp</a> や <a href="https://factory.ai/news/software-factory">Factory.ai</a> のように Software Factory を構築するための製品を提供する企業も現れています。</p>
<p>ただ、自分の組織で作ろうとすると何から決めればよいのかがはっきりしません。同じ言葉で呼ばれていても、人間の関わり方が大きく違うからです。<a href="https://factory.strongdm.ai/">StrongDM</a> は人間がコードを書かず、レビューもしない体制を掲げ、HumanLayer の <a href="https://ai.engineer/talks/Ib5GBkD555M-harness-engineering-is-not-enough-why-software">Dex Horthy</a> は人間がコードを読まない運用は長期的に破綻すると主張しています。</p>
<p>しかし比較すると、これらの違いは構造の違いではありません。工程の構成はほとんど共通していて、違うのは、どの工程をエージェントに任せ、どの工程に人間の判断を残すかです。本記事では、Software Factory を設計するときに何を決める必要があるのかを整理します。</p>
<h2>1. Software Factory とは何か</h2>
<p>Software Factory の定義としてよく参照されるのは、Addy Osmani による次の説明です。</p>
<blockquote>
<p>A software factory is many harnessed loops running at once, fed by a queue of work and drained through a review gate into production, with humans owning the whole thing from above. It is not a bigger agent; it is an org chart made of loops.</p>
<p>— Addy Osmani, <a href="https://addyosmani.com/blog/software-factories/">Software Factories, Light and Dark</a></p>
</blockquote>
<p>Software Factory とは、Harness で制御された複数の Loop を同時に動かし、キューから作業を受け取り、レビューゲートを通して本番環境へ出荷する仕組みであり、人間がその全体に責任を持ちます。1 つの大きなエージェントではなく、Loop で構成された組織図だという説明です。</p>
<p>本記事でも、この定義に沿って Software Factory を扱います。</p>
<img src="https://cdn.hashnode.com/uploads/covers/6ac08dc1e458e2a1f27e88e5/d40197c4-571b-4e68-99c9-30f1200df6f1.png" alt="Software Factory の全体像" style="display:block;margin:0 auto" />

<em>Software Factory の全体像</em>

<h3>構成する 4 つの要素</h3>
<ul>
<li><p><strong>フィードバックループ</strong>：出荷で終わらず、本番環境の監視結果が次の作業になる</p>
</li>
<li><p><strong>複数の Loop</strong>：1 つの汎用エージェントではなく、役割ごとに分かれた Loop で構成する</p>
</li>
<li><p><strong>Harness による制御</strong>：エージェントは、隔離環境、使えるツール、記録、完了条件が決められた範囲で動く</p>
</li>
<li><p><strong>人間による判断</strong>：何を作るか、何を正しいとするか、どの条件なら出荷してよいかは人間が決める。個々の変更を人間が読むかどうかは、この条件の一部として決まる</p>
</li>
</ul>
<h3>SDLC と Software Factory</h3>
<p>Software Factory が対象にするのは、SDLC (Software Development Life Cycle) の全体です。<a href="https://www.warp.dev/blog/a-guide-to-cloud-software-factories-for-engineering-leaders">Warp</a> は Software Factory を、SDLC の主要な部分を自動化するシステムと説明しています。<a href="https://factory.ai/news/software-factory">Factory.ai</a> も、トリアージから計画、実装、検証、リリース、監視まで、SDLC の各工程にエージェントを配置する構成を示しています。</p>
<p>SDLC の一部は、これまでも自動化されてきました。CI/CD は、変更の統合からテスト、リリースまでを自動化するプラクティスです。一方で、要件の整理、設計、実装は人間が担ってきました。コーディングエージェントの登場によって実装の自動化が始まり、<a href="https://www.forrester.com/blogs/agentic-software-development-takes-the-lead-from-code-assistants-to-orchestrated-sdlc-agents/">Forrester</a> は、2026 年にはエージェントの担う範囲が分析、計画、設計、ビルド、テスト、デリバリーにまで広がり、エージェント同士が連携して動くようになったと分析しています。</p>
<p>Software Factory は、この流れの延長にあります。SDLC の各工程にエージェントを配置し、工程どうしをフィードバックループとしてつないで運用する仕組みです。</p>
<p>工程の一部だけを自動化すると、別の工程に負荷が移ります。<a href="https://blog.cloudflare.com/ja-jp/agent-development-lifecycle/">Cloudflare</a> は、AI によって実装が速く安くなった結果、SDLC の後続の工程を担う人に大きな負荷がかかるようになったと述べています。Software Factory を工程の一部ではなく SDLC 全体として設計する必要があるのは、このためです。</p>
<h2>2. なぜ今、Software Factory なのか</h2>
<h3>1968 年からある構想</h3>
<p>Software Factory という考え方自体は新しくありません。GE の <a href="https://web.archive.org/web/20010406041743/http:/www.bobbemer.com/FACTORY.HTM">Bob Bemer</a> は 1968 年、ソフトウェアの開発を計算機上の統一された環境で行い、ツール、品質管理、計測、記録を一元化する仕組みを「Software Factory」と名付けて提案しました。同じ年の NATO ソフトウェア工学会議では、Douglas McIlroy が再利用可能なソフトウェア部品の量産を論じています。</p>
<h3>これまで実現が難しかった理由</h3>
<p>工業製品の工場は、一度設計を決めれば、同じ製品を繰り返し作ります。ソフトウェアには、この量産にあたる工程がありません。できあがったプログラムの複製は一瞬で終わり、作業の大半は、何を作るかを決め、要求を設計とコードに落とし込む部分です。Fred Brooks は 1986 年の「<a href="http://www.cgl.ucsf.edu/Outreach/pc204/NoSilverBullet">No Silver Bullet</a>」で、ソフトウェア開発の本質的な難しさは、何を作るかという概念構造を仕様化し、設計し、その正しさを確かめることにあり、それをプログラミング言語で書き表す作業は本質ではないと述べています。</p>
<img src="https://cdn.hashnode.com/uploads/covers/6ac08dc1e458e2a1f27e88e5/b37284ac-7d60-423e-9f33-97750c204799.png" alt="工業製品とソフトウェアで、作業の中心となる工程は異なる" style="display:block;margin:0 auto" />

<em>工業製品とソフトウェアで、作業の中心となる工程は異なる</em>

<p>例えば、「オンボーディングを改善したい」という依頼を受けたら、何が課題なのか、誰を対象にするのか、成果をどう測るのか、既存システムのどこを変えるのかを、依頼ごとに判断する必要があります。この、依頼ごとに異なる要求に合わせて作業内容を組み立てる部分は、人間が担うほかありませんでした。</p>
<h3>コーディングエージェントで変わったこと</h3>
<p>コーディングエージェントは、自然言語で書かれた曖昧な依頼と既存のコードベースを読み、調査、実装、テスト、修正を繰り返し実行できます。これまで人間にしかできなかった、依頼ごとに作業を組み立てる部分の一部を、エージェントが担えるようになりました。</p>
<p>その結果、関心は個人によるコーディングエージェントの利用から、組織として開発の流れ全体を設計することへ移りつつあります。エージェントが速くしたのは、計画、設計、実装、プッシュまでの開発者個人の作業です。その先にあるレビューの待ち行列、アーキテクチャの判断、コンプライアンスの承認、チーム間の引き渡し、出荷の承認は、人間が担ったまま変わっていません。個人の作業がいくら速くなっても、変更はここで待たされるので、組織全体の開発速度はそれほど上がらないのです。</p>
<p>つまり、変わったのは構想そのものではなく、工程の中で作業を担う主体です。</p>
<h2>3. Loop、Harness、Factory</h2>
<p>Software Factory の構造を理解するには、Addy Osmani が <a href="https://addyosmani.com/blog/software-factories/">Software Factories, Light and Dark</a> で示した Loop、Harness、Factory の 3 層に分けて考えるのが有効です。</p>
<h3>Loop：エージェント作業の最小単位</h3>
<p>Loop は、1 つのエージェントが 1 つの作業を繰り返し実行する単位です。情報を集め、作業し、結果を確かめ、完了条件を満たすまでこれを繰り返します。</p>
<img src="https://cdn.hashnode.com/uploads/covers/6ac08dc1e458e2a1f27e88e5/41c048b4-72b4-4b09-ada7-43915a7a97fb.png" alt="Loop の基本形" style="display:block;margin:0 auto" />

<em>Loop の基本形</em>

<p>Loop を設計するときの要点は 3 つです。</p>
<ul>
<li><p><strong>完了条件を外部に置く</strong>：「テストが通る」「Lint が通る」のように検証できる条件を終了条件にし、判定は作業したエージェント自身ではなく別の仕組みに任せます。作る側と確かめる側を分けるのは、生成と判定を同じコンテキストで行うと、同じ思い込みによる誤りを検出しにくいためです。</p>
</li>
<li><p><strong>短く保つ</strong>：<a href="https://github.com/humanlayer/12-factor-agents/blob/main/content/factor-10-small-focused-agents.md">Dex Horthy</a> は、エージェントが安定して動くのは 3〜10 ステップで、20 ステップを超えると文脈を失い始めるとしています。短い Loop は検証も容易です。</p>
</li>
<li><p><strong>状態をコンテキストの外に置く</strong>：実行をまたいで必要な情報は、コンテキストではなくファイルや Issue トラッカーに記録します。<a href="https://ghuntley.com/loop/">Ralph loop</a> は、毎回新しいコンテキストで仕様を読み直し、1 回に 1 つの作業だけを行うことでこれを徹底しています。</p>
</li>
</ul>
<p>なお「Loop」という語は、エージェント内部の実行ループから、SDLC 全体を回す仕組みまで幅広い意味で使われています。<a href="https://www.oreilly.com/radar/what-the-hell-is-a-loop-anyway/">Laurie Voss</a> はこれを 4 つに区別しています。本記事の Loop は、このうち最も内側の実行ループを指し、Inner loop と同じものです。意図から出荷、監視を経て次の意図に戻る工程全体は、これと区別してフィードバックループと呼びます。</p>
<p>ここで重要なのは、人間がエージェントに 1 回ずつ指示を出す運用から、エージェントに指示を出し続ける仕組みを人間が設計する運用へ変わる点です。人間の役割は、エージェントに指示を出すことから、Loop を設計することへ移ります。</p>
<h3>Harness：Loop を動かす実行環境</h3>
<p>モデル単体はエージェントではありません。モデルは入力を受け取って文章を返すだけで、状態の保持、コードの実行、外部情報の取得はできません。これらを補う、モデル以外のコード、設定、実行ロジックのすべてが Harness です。</p>
<p>Software Factory の文脈では、Harness は Loop が動作する環境と、その制約です。主に次の 4 つで構成されます。</p>
<img src="https://cdn.hashnode.com/uploads/covers/6ac08dc1e458e2a1f27e88e5/753449bf-b4ad-4f12-8332-7aad614ff6e8.png" alt="Harness の構成要素" style="display:block;margin:0 auto" />

<em>Harness の構成要素</em>

<ul>
<li><p><strong>サンドボックス</strong>：エージェントを隔離して実行する環境</p>
</li>
<li><p><strong>ツール</strong>：Git、テスト、LSP、ブラウザなど、エージェントが使える機能</p>
</li>
<li><p><strong>メモリ</strong>：実行をまたいで引き継ぐ状態や作業記録</p>
</li>
<li><p><strong>ゲート</strong>：何をもって作業完了とみなすかの判定</p>
</li>
</ul>
<p>Loop がエージェントの振る舞いで、Harness はその振る舞いが動く環境です。Harness がなければ、エージェントはどこで止まるべきか、何を変更してよいかを判断できません。特にゲートは、完了の判定をエージェント自身の申告ではなく、外部の仕組みに委ねる点で重要です。</p>
<h3>Factory：複数の Loop を組み合わせた開発体制</h3>
<p>Factory は、1 章の定義のとおり、Harness で制御された複数の Loop を並行して動かし、キューから作業を受け取り、レビューゲートを通して出荷する仕組みです。</p>
<img src="https://cdn.hashnode.com/uploads/covers/6ac08dc1e458e2a1f27e88e5/5052ba73-d0fb-41ba-8ea1-2935c13416ce.png" alt="各 Loop の成果が 1 つのレビューゲートに集まる" style="display:block;margin:0 auto" />

<em>各 Loop の成果が 1 つのレビューゲートに集まる</em>

<p>Factory は、1 つの高性能なエージェントではありません。Issue、アラート、スケジュール、チャットといったイベントが Issue トラッカーのラベルやボードにキューとして積まれ、オーケストレーターがそれを読んで Loop を起動し、状態を管理します。Loop は、トリアージ、仕様化、実装、レビューといった工程ごと、またはバグ修正、依存ライブラリの更新、ドキュメントといった作業の種類ごとに分けます。</p>
<p>Loop 同士は、仕様、Issue、プルリクエスト、調査レポートといった成果物を介してつながります。<a href="https://igoro.com/archive/software-factories/">Igor Ostrovsky</a> はこの関係を、成果物をノード、エージェントの処理をエッジとするグラフとして整理しています。エージェントは各エッジに割り当てられた処理を担い、次のノードへ進めるかは人間の承認と自動チェックが決めます。ノードとエッジに何を置くかは論者によって異なりますが、エージェントが経路を自分で選ばず、人間が決めた経路の上で作業する点は Graph Engineering と呼ばれる考え方と共通です。<a href="https://blog.cloudflare.com/astro-issue-triage/">Astro における Software Factory</a> では、再現、診断、修正の各エージェントが <code>report.md</code> を介して結果を受け渡しています。</p>
<p>このように、設計の対象は個々のコード変更から、Loop、Harness、そして Loop 同士の連携に移ります。</p>
<h2>4. 意図から出荷までの工程</h2>
<p>各社が公開している仕組みを比較すると、名称や使っているツールは違っても、工程の構成はほとんど共通しています。</p>
<img src="https://cdn.hashnode.com/uploads/covers/6ac08dc1e458e2a1f27e88e5/e50a975f-c5d8-4ea8-afb4-bd9107bde165.png" alt="意図から出荷までの工程" style="display:block;margin:0 auto" />

<em>意図から出荷までの工程</em>

<p><a href="https://www.warp.dev/blog/a-guide-to-cloud-software-factories-for-engineering-leaders">Warp</a> はこの流れを「triage → spec → implement → review → verify → ship → monitor」と整理しています。Warp はレビューを検証の前に置いていますが、本記事では、自動化された検証を人間のレビューの前に置いて整理します。<a href="https://factory.ai/news/software-factory">Factory.ai</a> も、外部からのシグナルが計画された変更になり、出荷と監視を経て次のシグナルを生む、継続的なフィードバックループとして説明しています。</p>
<p>出荷は工程の終わりではありません。障害、エラー率、レイテンシ、ユーザーからの報告といった本番環境のシグナルが、次の作業としてキューに戻ります。例えば、<a href="https://newsletter.pragmaticengineer.com/p/openai-software-factory">Pragmatic Engineer</a> が取材した OpenAI の「Perf Factory」では、本番環境のアラートやダッシュボードから性能の劣化を検出するとエージェントが原因の調査と修正案の作成を始めます。</p>
<h3>工程を支える基盤</h3>
<p>これらの工程を動かすには、次のような基盤が必要です。</p>
<img src="https://cdn.hashnode.com/uploads/covers/6ac08dc1e458e2a1f27e88e5/85414d79-4155-486d-85a6-0dcd632c1918.png" alt="工程を支える基盤の構成" style="display:block;margin:0 auto" />

<em>工程を支える基盤の構成</em>

<table>
<thead>
<tr>
<th>基盤</th>
<th>役割</th>
</tr>
</thead>
<tbody><tr>
<td>オーケストレーター</td>
<td>トリガーを受けて Harness を起動し、作業の状態を管理する</td>
</tr>
<tr>
<td>Harness</td>
<td>Loop を動かす実行環境。履歴を読み、モデルを呼び、ツールの呼び出しをサンドボックスなどに振り分ける</td>
</tr>
<tr>
<td>セッション</td>
<td>実行中の会話と作業状態を保存し、Harness やサンドボックスを作り直しても再開できるようにする</td>
</tr>
<tr>
<td>ゲートウェイ</td>
<td>モデルとツールへのアクセス、認証、コスト管理を 1 か所に集約する</td>
</tr>
<tr>
<td>コンテキスト</td>
<td>コードベース、ドキュメント、運用知識をエージェントに提供する</td>
</tr>
<tr>
<td>サンドボックス</td>
<td>エージェントが書いたコードを隔離して実行する環境。並行して増やせ、使い捨てにできる</td>
</tr>
</tbody></table>
<p><a href="https://ai.engineer/talks/17-YSUHo6Lk-agentic-sdlc-at-uber-building-blocks-ubers">Uber</a> は、これらを会社全体で共有する基盤として整備しています。サンドボックスの DevPods、Model Gateway と MCP Gateway、コードベースと運用知識をつなぐ Context Graph を各チームが共通に使い、その上にそれぞれのワークフローを作っています。</p>
<p><a href="https://shopify.engineering/under-the-river">Shopify の Aquifer</a> は、エージェントの判断を担う Harness と、コードを実行するサンドボックスを別々に管理し、会話の状態をデータベースに保存しています。Harness とサンドボックスはいつでも作り直せる一方、セッションは保持され続けます。<a href="https://workos.com/blog/project-horizon">WorkOS</a> も、オーケストレーターをサンドボックスの外に置く構成を採っています。どちらも、壊れてもよい部分と保持すべき部分を分けて設計しています。</p>
<h2>5. 検証がボトルネックになる</h2>
<p>Software Factory を運用すると、制約になるのはコードの生成ではなく、その検証であることが明らかになります。ただし、検証のすべてが制約になるわけではありません。型チェック、Lint、テストのように合否が機械的に決まる検証は、環境を水平に増やせるように整えれば、エージェントに合わせて並行して動かせます。</p>
<p>制約になるのは、結果が正しいか、作るべきものを作っているかを判断する検証です。エージェントは並行して何十も動かせますが、この判断を担う人間のレビュー能力は、同じ速さでは増やせません。レビューだけではありません。アーキテクチャの判断、コンプライアンスの承認、出荷の承認といった、人間の判断を待つ工程はどれも同じ性質を持ちます。エージェントを増やして生成量を増やすほど、判断待ちの変更が積み上がります。</p>
<img src="https://cdn.hashnode.com/uploads/covers/6ac08dc1e458e2a1f27e88e5/5251f294-5b10-4d4f-ae6b-20ef922fcb88.png" alt="エージェントを増やしても、レビューゲートの処理能力は増えない" style="display:block;margin:0 auto" />

<em>エージェントを増やしても、レビューゲートの処理能力は増えない</em>

<h3>検証の段階</h3>
<p>本記事では、検証を次の 4 段階に整理します。後の段階ほど、判定に使う情報がコードの外へ広がり、人間の判断が占める割合がおおむね増えます。</p>
<img src="https://cdn.hashnode.com/uploads/covers/6ac08dc1e458e2a1f27e88e5/06d8765b-9a0b-4432-b8e3-b2c3bbcd4e66.png" alt="検証の 4 段階" style="display:block;margin:0 auto" />

<em>検証の 4 段階</em>

<table>
<thead>
<tr>
<th>段階</th>
<th>判定に使う情報</th>
<th>内容</th>
</tr>
</thead>
<tbody><tr>
<td>静的な検証</td>
<td>コード</td>
<td>型、Lint、ビルド、セキュリティスキャン、アーキテクチャ上のルール</td>
</tr>
<tr>
<td>振る舞いの検証</td>
<td>実行結果</td>
<td>単体テスト、結合テスト、E2E テスト。エージェントから隠したテストを含む</td>
</tr>
<tr>
<td>本番への影響の検証</td>
<td>本番環境の構成とテレメトリー</td>
<td>出荷前に、変更が本番環境のどのリソースにどう影響するかを評価する</td>
</tr>
<tr>
<td>人間による判断</td>
<td>目的と文脈</td>
<td>プロダクトとしての妥当性、設計、長期的な保守性</td>
</tr>
</tbody></table>
<p>検証の仕組みそのものをエージェントから切り離した組織もあります。<a href="https://factory.strongdm.ai/">StrongDM</a> は、エージェントがテストを通すためだけに <code>return true</code> を書いたことをきっかけに、テストをコードベースの外に置く方針に切り替えました。エージェントから見えない場所にシナリオを置き、Okta や Slack などの外部サービスの API と振る舞いを模した Digital Twin Universe の上で検証しています。</p>
<p>また、本番への影響の検証は、差分の外にある情報を使います。<a href="https://polylane.com/blog/how-we-prevent-slop-from-hitting-prod/">Polylane</a> は、型チェックもテストもコードレビューも差分しか見ていない点を問題視し、変更が本番環境のどのリソースに影響するかを調べて、出荷してよいかを判定します。</p>
<img src="https://cdn.hashnode.com/uploads/covers/6ac08dc1e458e2a1f27e88e5/becbca27-9806-4801-a377-f65efdf76ec3.png" alt="Polylane の検証手順" style="display:block;margin:0 auto" />

<em>Polylane の検証手順</em>

<h3>人間による判断が残る理由</h3>
<p>検証の 4 段階のうち、人間による判断を除く 3 段階は自動化が進んでいます。Harness は、ルールとして書き下せる条件であれば強制できます。しかし、テストは誰かが思いついた振る舞いしか検証できません。次のような品質は、ルールとして書き下しきれません。</p>
<ul>
<li><p><strong>保守性</strong>：変更が 1 か所に収まり、ほかの部分に手を入れなくて済む構造であること。回帰テストは壊れたことを検出できますが、変更のたびに多くの箇所を直す必要がある構造かどうかは、数か月後に別の変更を加えたときに初めて分かります。</p>
</li>
<li><p><strong>トレードオフ</strong>：エージェントは与えられた目標に最適化します。競合する要求のあいだでバランスを取ることや、技術的には正しい解がプロダクトとして誤っていると気づくことは、目標には含まれません。</p>
</li>
<li><p><strong>何を作り、何を出荷するか</strong>：どの問題を解くか、どのアーキテクチャを選ぶか、品質の基準をどこに置くか、根拠が出荷に十分かを決めることは人間に残ります。</p>
</li>
</ul>
<p>保守性が担保できない一因は、モデルの学習方法にあると考えられます。コーディング能力を伸ばす強化学習では、テスト結果のように機械的に検証できる結果を報酬にする RLVR (Reinforcement Learning with Verifiable Rewards) が広く使われています。しかし保守性の低さは、数か月後に別の変更が広い範囲の修正を強いたとき、初めてコストとして現れます。<a href="https://ai.engineer/talks/Ib5GBkD555M-harness-engineering-is-not-enough-why-software">Dex Horthy</a> は、このコストを過去の判断の報酬に戻す方法が確立していないと指摘しています。Harness やレビュー用のエージェントで品質は改善できますが、長期的な保守性をモデルに学習させることは難しいままです。</p>
<img src="https://cdn.hashnode.com/uploads/covers/6ac08dc1e458e2a1f27e88e5/4d32dd96-a2c6-4c70-8364-103ec2645b1f.png" alt="テストの結果はすぐに分かるが、保守性のコストは数か月後の変更で現れる" style="display:block;margin:0 auto" />

<em>テストの結果はすぐに分かるが、保守性のコストは数か月後の変更で現れる</em>

<p>人間がコードを読まなくなると、もう 1 つ問題が生じます。システムに対する人間の理解が失われていくことです。Addy Osmani はこの状態を「<a href="https://addyosmani.com/blog/comprehension-debt/">Comprehension Debt</a>」と呼んでいます。存在するコードの量と、人間が理解しているコードの量の差が広がっていく状態を指します。</p>
<p><a href="https://ai.engineer/talks/Ib5GBkD555M-harness-engineering-is-not-enough-why-software">HumanLayer</a> は 2025 年に、人間がコードを読まない運用を数か月試しました。その結果、エージェントでは解決できない障害が起き、それまで読んでいなかったコードを、障害対応の最中に一から読み解くことになったと報告しています。</p>
<img src="https://cdn.hashnode.com/uploads/covers/6ac08dc1e458e2a1f27e88e5/ca6c843c-3674-4715-b3ab-6e4dc0134467.png" alt="Comprehension Debt の蓄積" style="display:block;margin:0 auto" />

<em>Comprehension Debt の蓄積</em>

<p>この報告が示しているのは、人間がコードを読まない運用の問題が、コードを生成できなくなることではない点です。問題は、変更や障害対応を続けるために必要な理解が、組織から失われることにあります。</p>
<h2>6. Light Factory と Dark Factory</h2>
<h3>違いは工程ごとの分担にある</h3>
<p><a href="https://www.danshapiro.com/blog/2026/01/the-five-levels-from-spicy-autocomplete-to-the-software-factory/">Dan Shapiro</a> は 2026 年 1 月、AI を使った開発を自動運転のレベルになぞらえて 5 段階に分類し、最上位を「Dark Factory」と名付けました。照明を落としたまま稼働する無人工場に由来し、人間がコードを読まずに出荷する状態を指します。対になる語として、Addy Osmani は人間がコードを読んでから出荷する体制を「Light Factory」と呼んでいます。違いはエージェントがどれだけ書くかではなく、個々の変更を出荷前に人間が読んで承認するかどうかにあります。Dark でも、何を作るか、何をもって検証とするかは人間が決めます。人間は個々の変更から、上流と仕組みの設計に移ります。</p>
<p>Light か Dark かは、組織全体で一度に決まるものではありません。テストに守られた依存ライブラリのパッチ更新は Dark、公開 API の変更は Light というように、変更の種類ごと、Loop ごとに決まり、同じ組織の中で混在します。Light と Dark を分ける基準は出荷前に人間がコードを読むかどうかですが、人間の判断を置く場所はレビューに限らず、課題の設定から障害対応までの各工程で決める必要があります。</p>
<p>各社が公開している仕組みを見ると、工程の構成はほとんど同じです。違いは、機械による検証をどこまで信頼し、どの工程に人間の判断を残すかにあります。</p>
<h3>分担を決める基準</h3>
<p>エージェントに任せてよい範囲の上限は、その結果を安く確実に検証できる範囲です。検証できない範囲を任せることはできません。検証できる範囲の中でも、失敗したときの損失や影響範囲に応じて、どこまで任せるかを決めます。実際の判断では、Loop ごとに次の観点を確認します。</p>
<table>
<thead>
<tr>
<th>観点</th>
<th>確認すること</th>
</tr>
</thead>
<tbody><tr>
<td>検証可能性</td>
<td>成功を機械的かつ客観的に確認できるか。エージェントが検証の仕組みを書き換えられないか</td>
</tr>
<tr>
<td>失敗時の損失</td>
<td>誤った変更が出荷された場合、どの程度の損失が出るか</td>
</tr>
<tr>
<td>影響範囲</td>
<td>影響が 1 つのモジュールにとどまるか、すべての利用者に及ぶか</td>
</tr>
<tr>
<td>可逆性</td>
<td>フィーチャーフラグやロールバックですぐに元に戻せるか</td>
</tr>
<tr>
<td>問題判明までの時間</td>
<td>誤りが数分で判明するか、数か月後まで判明しないか</td>
</tr>
</tbody></table>
<img src="https://cdn.hashnode.com/uploads/covers/6ac08dc1e458e2a1f27e88e5/ec37df7b-a653-48a6-af7a-b400fe4833e0.png" alt="Loop ごとにエージェントへ任せる範囲を決める手順" style="display:block;margin:0 auto" />

<em>Loop ごとにエージェントへ任せる範囲を決める手順</em>

<h3>変更の種類による目安</h3>
<p>同じ組織の中でも、変更の種類によって任せる範囲は変わります。上の観点を満たすことを前提にした目安は次のとおりです。自動マージまで任せられるのは、エージェントが書き換えられない検証があり、影響範囲が小さく、すぐに戻せる場合に限ります。</p>
<table>
<thead>
<tr>
<th>変更の種類</th>
<th>エージェントに任せる範囲の目安</th>
</tr>
</thead>
<tbody><tr>
<td>Lint エラー、型エラーの修正</td>
<td>自動マージまで</td>
</tr>
<tr>
<td>依存ライブラリのパッチバージョン更新</td>
<td>自動マージまで。公開から一定期間が経ち、供給元を確認できるバージョンに限る</td>
</tr>
<tr>
<td>旧バージョンへのバックポート</td>
<td>エージェントが実装と検証を行い、人間は要点を確認する</td>
</tr>
<tr>
<td>大規模な移行作業</td>
<td>エージェントが実装し、人間が段階ごとにレビューする</td>
</tr>
<tr>
<td>新機能の開発</td>
<td>人間が設計し、エージェントが実装し、人間がレビューする</td>
</tr>
<tr>
<td>公開 API やデータベーススキーマの変更</td>
<td>人間による設計判断と承認が必要</td>
</tr>
<tr>
<td>認証や課金に関わる変更</td>
<td>人間が各工程に深く関与する</td>
</tr>
</tbody></table>
<p>もう 1 つの方法は、人間の判断を実装後のレビューに追加するのではなく、実装前の工程に移すことです。プロダクトとしての要件、アーキテクチャ、プログラムの構造 (型、関数のシグネチャ、呼び出し関係)、実装の順序を事前に合意しておけば、レビューで初めて設計を議論する必要がなくなり、合意した内容どおりに実装されているかの確認に論点を絞れます。</p>
<img src="https://cdn.hashnode.com/uploads/covers/6ac08dc1e458e2a1f27e88e5/bfea2edb-2a54-4591-8a3c-13dad11bf56e.png" alt="人間の判断を実装の前に移す" style="display:block;margin:0 auto" />

<em>人間の判断を実装の前に移す</em>

<h3>任せる範囲は Harness で強制する</h3>
<p>任せる範囲を方針として決めるだけでは不十分です。エージェントがその範囲を超えられないよう、Harness の設定として組み込む必要があります。</p>
<img src="https://cdn.hashnode.com/uploads/covers/6ac08dc1e458e2a1f27e88e5/87667880-f426-4496-bf94-d27d442e001c.png" alt="エージェントに許可する操作と、許可しない操作" style="display:block;margin:0 auto" />

<em>エージェントに許可する操作と、許可しない操作</em>

<p>操作の可否に加えて、再試行の回数、実行時間、コストの上限といった停止条件や、「認証に関わるファイルを変更したら人間のレビューを必須にする」といった条件も、Harness で定めます。検証に失敗した変更はレビュー依頼や自動マージに進めず、失敗の記録だけを残す、サンドボックスには作業に必要な最小限の秘密情報だけを渡す、外部から受け取る入力は信頼しない、といった設定がこれにあたります。</p>
<h2>7. 人間はどこで何を判断するのか</h2>
<h3>作業の実行から、目的と品質の判断へ</h3>
<p>Software Factory でも人間の役割はなくなりません。重心が移ります。調査、実装、テスト、報告の繰り返し (Inner loop) はエージェントが担い、人間はその外側 (Outer loop) で判断を担います。エージェントから人間へ渡されるのは、作業の過程ではなく根拠です。差分とテスト結果に加え、変更が本番環境のどこに影響するかを示す材料まで含めて、人間はそれを見て判断します。</p>
<img src="https://cdn.hashnode.com/uploads/covers/6ac08dc1e458e2a1f27e88e5/4ee424ac-4a52-4221-8347-76b3c6e9e118.png" alt="Inner loop と Outer loop の分担" style="display:block;margin:0 auto" />

<em>Inner loop と Outer loop の分担</em>

<p>人間が担う判断は 4 つに整理できます。</p>
<ul>
<li><p><strong>目的</strong>：どの課題に取り組み、何を作るか</p>
</li>
<li><p><strong>制約</strong>：アーキテクチャ、品質の基準、Harness とゲートの方針</p>
</li>
<li><p><strong>検証の信頼範囲</strong>：どの検証を信頼し、どの変更をどれだけ人間が読むか</p>
</li>
<li><p><strong>出荷と責任</strong>：根拠を見て出荷を決め、結果を引き受け、理由を説明できるようにする</p>
</li>
</ul>
<h3>仕組み自体を評価し、改善する</h3>
<p>Software Factory は、一度構築すれば終わる仕組みではありません。エージェントが失敗した原因を分類し、プロンプト、スキル、テスト、コンテキストの改善に反映することで、次の実行の成功率を高めていきます。<a href="https://blog.cloudflare.com/astro-issue-triage/">Cloudflare</a> は Astro の Issue 対応にエージェントを導入し、エージェントが修正に失敗した箇所を、抽象化の分かりにくさ、ドキュメントの不足、テストの不足を示す手がかりとして扱っています。</p>
<img src="https://cdn.hashnode.com/uploads/covers/6ac08dc1e458e2a1f27e88e5/ab7c1d01-69d9-4f9c-a01f-6f2f977ab9e0.png" alt="エージェントの失敗を、次の実行の改善に反映する" style="display:block;margin:0 auto" />

<em>エージェントの失敗を、次の実行の改善に反映する</em>

<p>改善の効果を知るには、まず成果を計測します。トークンの消費量やプルリクエストの数は成果を表しません。<a href="https://www.uber.com/gb/en/blog/efficient-software-factory/">Uber</a> は、マージされたプルリクエスト 1 件あたりのコスト、リバート率、障害からの平均復旧時間 (MTTR) といった、成果に結びついたコストと品質の指標を追跡しています。</p>
<p>ただし本番の計測だけでは、Harness の変更が効いたかは分かりません。自動マージ率が同じ 2 つの Factory でも、一方はコードの質が高く、他方はレビューが問題を見逃しているだけかもしれません。簡単な作業が増えたから成功率が上がった、チェックを飛ばしたから速くなった、という見かけの改善もあります。評価は、この計測を条件をそろえて行うことです。例えば、過去に処理した依存ライブラリ更新の Issue を 50 件選び、スキルを書き換えた Harness で再実行して、テストの合格率、人間の修正が必要だった件数、プルリクエスト 1 件あたりのコストを旧 Harness と比べます。Warp は <a href="https://www.warp.dev/factories/benchmarks">Factory Benchmarks</a> を構築し、過去の実行を再生してモデルや Harness の構成を同じ採点で比べられるようにしています。</p>
<h3>まとめ</h3>
<p>Software Factory の構造は、各社が公開している仕組みを比べるとかなり似ています。違いは各工程を誰が担うかにあり、その上限を決めるのはエージェントの性能ではなく、結果を検証できるかどうかです。</p>
<p>多くの組織では、エージェントの導入が先になり、検証は後回しになりがちです。しかし順番は逆です。エージェントに任せる範囲を広げられるのは、エージェントから隠したテスト、本番環境への影響評価、Harness のゲートといった検証がある工程だけです。検証がなければ、品質を担保する手段は人間がコードを読むことしかなく、Factory はレビュー待ちの変更を速く積み上げる装置になります。エージェントやモデルを選ぶ前に、検証を整えます。</p>
<p>検証が整ったら、次は評価です。検証は個々の変更を出してよいかに答え、評価は Harness を変えて Factory が良くなったかに答えます。評価がなければ、プロンプトやスキルの変更は推測のまま積み上がります。評価には過去の実行が要るので、記録は Factory を動かし始めた日から取ります。</p>
<p>検証と評価を整えても、エージェントに渡せないものが残ります。目的、制約、検証の信頼範囲、出荷と責任という人間の判断です。検証できるものはエージェントに任せ、残りは人間が判断します。Software Factory の設計とは、この境界を引き、検証を広げて境界を動かし続けることです。</p>
]]></content:encoded></item></channel></rss>