AIエージェントへの複数指示は別チャットか1チャット一括か?5件バルクで1件2.4分化した実測録
作成日:

AIエージェントへの複数指示は別チャットか1チャット一括か?5件バルクで1件2.4分化した実測録


論旨

Antigravity や Claude Code、Cursor といった自律型 AI エージェントで複数の記事改修やバグ修正を進める際、「1 件ずつ別々の新規チャットに分けて頼むべきか、それとも 1 つのチャットに複数件をまとめて一括(バルク)指示するべきか?」 という疑問は、毎日の開発効率を左右する切実なテーマです。世間の定説では「1 つのチャットに複数タスクを詰め込むとコンテキスト(文脈)が肥大化して AI の精度が落ちるため、1 タスク 1 チャットに分割せよ」と語られることが少なくありません。

しかし、当ラボ(公開記事総数 785記事:検証録 370記事・AI国家構想 415記事、設計ルール 1,372行)において、2026 年 11 月 15 日に同一モデル Gemini 4 Carbon (High)・同一ワークフロー /gsc-fix(Search Console 診断 → 原稿 SEO 補強 → 双方向リンク注入・機械検問 → Astro 本番ビルド& SFTP 転送 → Playwright 実機検証) を用いて「1 件単独チャット実行(実験 A)」と「1 チャット 5 件バルク一括実行(実験 B)」の生トランスクリプト(transcript.jsonl)を完全比較したところ、従来の定説を覆す決定的な実測データが得られました。

結論からお伝えすると、1 件単独チャット(実験 A)では完了までに 16.7分(1 記事あたり 16.7分・5 件単純換算で約 83.5分[推論を含む試算]) を要したのに対し、排他サブエージェント 3 班並列と前後パイプライン統合を組み合わせた 1 チャット 5 件バルク実行(実験 B・自動逆リンク注入を含め計 13 ファイル同時更新)は、先行チャットのデプロイ待機 7.0 分を含めても全体 19.0分(1 記事あたり 3.8分)、純バルク実行区間ではわずか 12.0分(1 記事あたり 2.4分) で完遂し、約 4.4倍〜7.0倍 の高速化(処理時間 77.2〜85.6% 短縮) を達成しました。

さらに驚くべきことに、5 倍の記事数を処理したにもかかわらず、親エージェントのログ容量は 385.9 KB → 237.2 KB(−38.5% 軽量化)、親の新規入力トークンは 592,385 → 341,275 トークン(−42.4% 削減)、親の総プロンプト量も 5,433,013 → 2,940,933 トークン(−45.9% 削減) へと逆にスリム化していたのです。本記事では、この逆転現象が起きる技術的メカニズムから、複数チャット同時起動が引き起こす 7 分間のロック競合の罠、そして 1 チャットあたり「3〜5 件」が最適スイートスポットとなる境界線まで、1 bit の狂いなく実測値で解剖します。

合わせて読みたい深まる関連情報
対象となる方
  • AI エージェントへの指示単位で迷っている方 : 複数の修正タスクや記事改善があるとき、1 件ずつ別チャットを立てるか、1 チャットにまとめて依頼するかで速度とトークン消費がどう変わるか知りたい方。

  • 複数チャットの並行実行で Git 競合やビルド待ちに悩んでいる方 : 同じリポジトリに対して複数の AI チャットを同時に走らせた結果、git commit や dist/ ビルドが衝突して手戻りや待機時間が発生した経験がある開発者の方。

  • 親コンテキストの肥大化を防ぎつつスループットを最大化したい方 : サブエージェントの排他並列分担とローカル CLI(Rust / SQLite)の一括処理を組み合わせ、最小のトークン消費で最大の成果を出す実践アーキテクチャを導入したい方。

複数タスクは別チャット分割か一括指示か

AI エージェントを日常業務やブログ運営、ソフトウェア開発に組み込むと、必ず直面するのが「粒度の似た複数タスクをどう捌くか」という問題です。たとえば Google Search Console(GSC)の診断データをもとに、検索順位やクリック率(CTR)を改善したい記事が 5 本見つかったとします。

このとき、素朴に考えると次の 3 つのやり方が思い浮かびます。

🧭 複数タスクをAIエージェントに処理させる3つのアプローチ
  • 方式①:1 件 1 チャット直列実行 : チャット A で 1 本目を指示し、ビルドと本番反映が終わったら新しいチャット B を開いて 2 本目を指示する、という作業を 5 回繰り返す最もオーソドックスな方法です。

  • 方式②:複数チャット同時並行(乱立)実行 : チャットウィンドウを 5 つ同時に開き、それぞれに 1 本ずつ別々の記事を指定して一斉にエンターキーを押す方法です。一見すると速そうですが、同一ワークスペースでは深刻な競合を引き起こします。

  • 方式③:1 チャット 5 件バルク一括実行(排他サブエージェント並列) : 1 つのチャットに対して「この 5 本を一括で改善して」とまとめて指示し、親エージェントが事前診断を行ったうえで、編集実務を排他サブエージェントへ並列分担し、最後の仕上げ検問・ビルド・デプロイ・実機検証を 1 回でまとめて完遂する方法です。

質問するおじさん

普通は「1 つのチャットに 5 件もまとめて頼んだら、AI が途中で混乱したり、コンテキストがパンクして遅くなったりするから 1 件ずつ別チャットに分けなさい」ってよく言われますよね?

解説ナビゲーター

何の工夫もせずに 1 人の AI に最初から最後まで 5 件を直列で書かせたら、確かにその通りになります!でも、「SQLite ピンポイント抽出 × 排他サブエージェント並列 × 前後パイプライン一括化」 が揃った環境では、まったく逆の結果になるんです。実際のログで比べてみましょう!

単独実行と一括実行の条件統一ベンチマーク

推測や感覚論を排するため、当ラボでは 2026 年 11 月 15 日、まったく同じタスク定義を持つスキル /gsc-fix を実行した 2 つの実稼働セッションの生ログ(transcript.jsonl)を取り出し、ステップ数・ツール呼び出し回数・経過時間・トークン消費量を 1 bit 単位で突き合わせました。

検証条件の公平性を担保するため、両セッションとも以下の同一環境・同一工程で実行しています。

🔬 ベンチマークの統一実験条件(2026年11月15日実施)
  • 使用モデルと実行環境 : いずれも Gemini 4 Carbon (High) を使用し、macOS(64GB メモリ+16GB APFS RAMDisk 環境)上の同一ワークスペース(公開記事 785記事 規模の Astro 7.x サイト)で稼働。

  • 工程① 事前診断(kb-search prep gsc) : SQLite に格納された Search Console 実績データと記事構造、内部リンク空き枠をミリ秒単位で一括抽出。

  • 工程② 原稿の SEO・構造補強 : クエリ取りこぼしやインデックス未登録の原因を解消する見出し・本文・構造化セクションの加筆修正(元の強み 100% 保全)。

  • 工程③ 一括仕上げ・逆リンク注入・機械検問(gemini-gate finish) : 強関連記事からの双方向内部リンク自動結線、太字・文字数・禁則検問、外部 URL 生存確認、意味一次検問(Gemini Decision 1)および SQLite 再同期。

  • 工程④ 本番ビルド& SFTP 自動転送(npm run 本番環境転送) : Git 同期、差分憲法監査、Astro 全ページ静的ビルド、本番サーバーへの SFTP 差分アップロード。

  • 工程⑤ Playwright 本番実機検証(browser_run_code_unsafe) : 公開された本番 URL にヘッドレスブラウザでアクセスし、H1・目次(TOC)・全画像の自然幅・モバイル横はみ出しゼロを 1 コールで機械検証。

  • 実験 A(1 件単独チャット実行)の対象 : 公開記事 1 本 を対象に /gsc-fix を完遂(逆リンク先を含め 計 3 ファイル変更)。

  • 実験 B(1 チャット 5 件バルク一括実行)の対象 : 公開記事 5 本 を 1 チャットで一括指定して /gsc-fix を完遂(自動逆リンク注入 8 本を含め 計 13 ファイル同時更新)。

処理時間が約7分の1へ短縮した実測比較

それではまず、実験 A(1 件単独チャット)と実験 B(1 チャット 5 件バルク一括)の全体稼働時間および「1 記事あたりの処理時間」の実測値をご覧ください。

なお、実験 B は実験 A の終了直前に別チャットから開始されたため、冒頭の 7.0分間 は「先行していた実験 A が同じワークスペースで編集〜本番デプロイ中だったため、Git コミットやビルド領域の競合を避けて安全待機していた時間」でした。先行デプロイが完了してからの 純バルク実行区間はわずか 12.0分 です。

1記事あたり処理時間と5記事換算トータル時間の比較(分)
2026年11月15日 /gsc-fix 実稼働トランスクリプト(Gemini 4 Carbon High)より算出
① 1件単独チャット × 5回直列(単純換算)実験Aの実測16.7分/本 × 5本を直列実行した場合(推論を含む単純換算)
約 83.5 分(5本換算)固定費5倍
② 実験A:1件単独チャット実測(1本あたり)1記事改修+逆リンク更新(計3ファイル変更・追加確認込みは21.5分)
16.7 分 / 本基準値
③ 実験B:5件バルク一括(先行待機7.0分込み全体)壁時計19.0分で5本(計13ファイル)完遂 → 1本あたり3.8分
全体 19.0 分(3.8 分 / 本)4.4倍高速
④ 実験B:5件バルク一括(純バルク実行区間トータル)先行デプロイ完了後の実作業から5本本番検証完了まで
全体 12.0 分(5本合計)1本単独より速い
⑤ 実験B:純バルク実行区間の1記事あたり時間12.0分 ÷ 5記事 = 2.4分/本(実験A比で処理時間85.6%短縮)
2.4 分 / 本(7.0倍高速)85.6%短縮
※①の83.5分は実験Aの実測値(16.7分/本)を5回繰り返した場合の推論を含む単純比例試算です

このグラフが示す事実は極めて強烈です。実験 A で 1 記事だけを改修するのに 16.7分 かかっていたのに対し、実験 B の純バルク実行区間では 5 記事すべて(計 13 ファイル)を改修・デプロイ・実機検証し終えるのにトータルで 12.0分 しかかかっていません。つまり、「1 件だけ単独で処理するよりも、5 件まとめてバルク並列で流した方が、全体の完了時刻すら 4.7 分も早かった」 のです。

さらに、両セッションの内部ステップ数・ツール呼び出し回数・コンテキスト規模まで含めた完全比較表を見てみましょう。

測定指標(transcript.jsonl 実測値) 実験 A:1 件単独チャット実行 実験 B:1 チャット 5 件バルク一括実行 実験 A 対比の増減・改善効果
対象記事数(総変更ファイル数) 1 記事(計 3 ファイル 変更) 5 記事(逆リンク 8 本含め 計 13 ファイル 変更) 処理対象 5.0 倍(ファイル数 4.3 倍)
全体稼働時間(壁時計) 16.7分(追加確認込み 21.5分) 19.0分(うち先行デプロイ待機 7.0分) 純バルク実行区間は 12.0分 で 5 本完遂
1 記事あたりの所要時間 16.7分 / 本 待機込み 3.8分 / 本 / 純区間 2.4分 / 本 約 4.4倍〜7.0倍 高速(77.2〜85.6% 短縮)
親 Planner 推論ステップ数 38 ステップ 31 ステップ 親の思考ターン数を 18.4% 削減
親ツール呼び出し総数 88 回 56 回 親のツール往復を 36.4% 削減
うち read_file(直接丸読み) 親 1 回 親 0 回 / 子 3 体合計 0 回 完全 read_file ゼロ(SQLite 100% 完結)
うち kb-search(SQLite 照会) 57 回 親 41 回 照会の一括化で親コール数を 28.1% 削減
うち gemini-gate(機械検問) 4 回 親 2 回(5 本一括 finish 等) 検問・逆リンク注入を 1 回に統合
並列サブエージェント数 0 体(親 1 人で直列処理) 排他 self サブエージェント 3 体並列 5 記事の編集実務を約 6.5分 で同時完遂
親トランスクリプト容量 385.9 KB 237.2 KB 親ログ容量が −38.5% 軽量化
親 Fresh 入力トークン 592,385 トークン(初回完了時 337,536) 341,275 トークン(※子 3 体計 555,097 は別枠破棄) 親の新規入力トークンを −42.4% 削減
親 総プロンプト送信量 5,433,013 トークン 2,940,933 トークン(※子 3 体計 2,681,695 は別枠破棄) 親の総プロンプト再送量を −45.9% 削減
1 記事あたり 16.7分 かかっていた作業が、なぜ 5 件まとめることで 2.4分 / 本(約 7 分の 1)にまで圧縮されたのでしょうか。そこには単なる「並列化」だけではない、AI 開発パイプライン特有の「固定費の償却」と「ターン税の削減」 という明確な裏付け(エビデンス)が存在します。

なぜ一括指示で処理時間が劇的に縮むのか

AI エージェントによる本番開発やブログ更新が「人間が手作業でテキストを数行書き換えるのとは比較にならないほど時間を食う」最大の理由は、原稿を書いている時間そのものよりも、前後の調査・検問・ビルド・デプロイ・実機確認にかかる「固定オーバーヘッド(固定費)」 にあります。

毎回発生するビルドと実機検証の固定費

当ラボのように、公開 785記事 規模のサイトで「1 bit の表示崩れもリンク切れも許さない」厳格な管理体制(ガバナンス)を敷いている環境では、たとえ 1 記事の修正であっても、後半に必ず以下の重い工程が走ります。

実験 B(5 件バルク一括実行)のログから、後半の仕上げ〜本番検証にかかった実測タイムを抜き出してみましょう。

⏱️ 実験Bで計測された「後半パイプライン(5記事・13ファイル一括)」の実測所要時間
  • ① 一括仕上げ&逆リンク 8 本自動注入(gemini-gate finish) : 5 本の改稿記事に対するフォーマット正規化、強関連記事 8 本への逆リンク自動挿入、SQLite インデックス更新まで含めて、実測わずか 2.4秒(2,427.9ms) で 1 回で完了。

  • ② 本番ビルド& SFTP 転送(npm run 本番環境転送) : Git 同期、変更 13 ファイルと全サイトの憲法監査、出典 URL 97 本の並列生存検証、Gemini Decision 1 による意味一次検問、Astro 全ページの静的ビルド、そして本番サーバーへの SFTP 転送までが、5 本まとめても実測 約 67秒 で 1 回で完了。

  • ③ Playwright 本番実機検証(browser_run_code_unsafe 1 コール) : 公開された本番 5 URL とサイトマップを単一スクリプト内でループ巡回し、H1・TOC 74 項目・画像 29 枚の自然幅・横はみ出しゼロを確認してブラウザを閉じるまで、実測 11秒 で 1 回で完了。

お分かりいただけるでしょうか。1 記事だけを修正する場合でも、Astro の全体ビルドや SFTP 転送、Playwright の起動・検証には毎回必ず 約 80秒〜120秒 前後の固定費(およびその前後の LLM 推論ステップ数ターン分=数分間)がかかります。

もし 5 記事を「1 件 1 チャット」に分けて 5 回直列で実行すれば、このビルド・転送・実機検証・前後確認のサイクルを 5 回丸ごと繰り返す ことになります。一方、1 チャットで 5 件をバルク処理すれば、この重い後半パイプラインは 最後にたった 1 回(合計約 80.4秒 =約 1.3 分)走らせるだけ で 5 記事すべてが本番へ反映されるのです。

排他サブエージェント3班並列の分担構造

もちろん、後半のビルドを 1 回にまとめただけでは、5 記事分の原稿編集そのものにかかる時間は減りません。もし親エージェント 1 人が 5 記事を順番に調べて順番に edit_file していけば、親のステップ数が 100 回を超えてタイムアウトの危険水域に入ってしまいます。

そこで実験 B では、親エージェントは 「司令塔(オーケストレーター)」 に徹し、重い編集実務を ファイル単位で完全排他分割した 3 体の self サブエージェント に並列委譲しました。実際の処理フローを図解すると次のようになります。

実験B(5件バルク一括・純実行12.0分)の排他並列サンドイッチ・パイプライン
PHASE 1(親・約3分)
SQLite一括事前診断と排他スライス割当

親エージェントが kb-search prep gsc と tree で対象 5 記事の GSC 指標・見出し行番号・逆リンク候補を一括抽出し、ファイルが絶対に重ならないよう 3 班(2 本・2 本・1 本)の作業指示書を作成。

PHASE 2(子3班並列・約6.5分)
排他サブエージェント3体による同時編集(read_file 0回)

3 体の self サブエージェントが同時に起動。各班とも read_file は一切使わず kb-search tree <slug>:L開始-L終了 で必要な行だけをミリ秒抽出し、5 記事の SEO 補強編集を約 6.5 分で同時完了して即座にメモリ解放。

PHASE 3(親・2.4秒)
Pure Rust finish による5本一括仕上げ&逆リンク8本注入

親が ./scripts/run_gemini_gate.sh finish に 5 記事のスラグを一括渡し。2,427.9ms(2.4秒)で 5 記事の整形と関連 8 記事への双方向リンク注入(計 13 ファイル更新)・DB 同期を 1 コール完遂。

PHASE 4(親・約67秒+11秒)
本番環境転送(67秒)& Playwright 5URL一括検証(11秒)

npm run 本番環境転送 で出典 97 本検証・Decision 1 検品・Astro ビルド・SFTP 転送を 1 回(67秒)で通し、Playwright browser_run_code_unsafe 1 コール(11秒)で全 5 URL(画像 29 枚・TOC 74 項目)を検証して完了。

親は前後の1回統合処理のみを担い、中間の5記事編集は3体のサブエージェントがread_fileゼロで同時完遂
ノルウェージャンフォレストキャット

おかっ⁉️ 親エージェントは自分で 5 本の記事をチマチマ書き換えるんじゃなくて、3 班の分身(サブエージェント)に 2 本・2 本・1 本と割り振って約 6.5 分で同時に書き上げさせ、最後の仕上げ(2.4秒)とデプロイ(67秒)とブラウザ確認(11秒)を 1 回でまとめて通した んでちぃね!そりゃ 12 分で全部終わるわけでちぃ!

また、ここで見逃せないのが 「親もサブエージェントも、read_file(ファイルの直接丸読み)が 0 回だった」 という点です。SQLite Official Documentation|35% Faster Than The Filesystem でも実証されている通り、多数の個別ファイルを OS のファイルシステム経由で開くよりも、単一の SQLite データベースから必要なブロックだけを抽出する方が I/O 効率は圧倒的に優れています。

当ラボでは全記事・全コード・GSC 統計が SQLite 化されているため、サブエージェント 3 体が同時に kb-search tree を叩いてもミリ秒単位で必要な数行だけが返り、無駄な全文読み込みが一切発生しなかったことが、並列フェーズ 6.5 分完遂の原動力となりました。

また、親エージェントが 3 体のサブエージェントを起動する際、互いにファイルを上書きしたり手戻りを起こしたりしないよう、以下の 「排他サブエージェント指示書(ブリーフ)の 4 原則」 を徹底しています。

📋 サブエージェント3班を6.5分で同時完走させた「排他指示書」の4原則
  • 原則①:所有ファイルの完全排他指定(1 班あたり 1〜2 ファイル限定) : 各サブエージェントの指示書冒頭に「あなたが編集してよいファイルは A と B の 2 本のみ。他の記事や共通設定ファイルには一切触れないこと」と明記し、サブエージェント間の書き込み衝突を物理的にゼロにします。

  • 原則②:親が抽出した「物理行番号マップ」と「改善クエリ」の事前注入 : サブエージェント自身がゼロから検索して迷走する時間を省くため、親が Phase 1 の prep gsc で取得した「現在の見出し行番号(例:L120-L185)」と「補強すべき Search Console クエリ・改善方針」を最初から指示書に埋め込んで渡します。

  • 原則③:read_file 禁止と kb-search tree ピンポイント抽出の強制 : サブエージェント内でもファイルの全文丸読み(read_file)を禁じ、編集対象箇所の前後数行だけを ./scripts/run_kb_search.sh tree <slug>:L開始-L終了 で確認して即座に edit_file する最短ルートを義務づけます。

  • 原則④:仕上げコマンド(finish・ビルド・コミット)の親への一元化 : サブエージェントには「原稿の edit_file と単体 check のみ」を行わせ、双方向逆リンクの自動注入(finish)や Git コミット、本番ビルドは、3 班すべてが完了した後に親エージェントが 1 回だけまとめて実行します。

一括指示なのに親の文脈が38.5%軽くなる理由

ここで、多くの AI 活用者が抱く最大の疑問――「なぜ 1 チャットに 5 件もまとめたのに、コンテキストが汚れて精度が落ちるどころか、逆に親のログ容量が 38.5% も軽くなったのか?」 という核心に踏み込みましょう。

従来の1チャット詰め込みが失敗する原因

まず、一般的な AI チャット環境で「1 チャットに 5 件のタスクをまとめて投げると失敗しやすい」と言われる理由は、数学的・構造的に正しい根拠があります。

通常の単一エージェント運用では、1 人の AI(親)が 1 本目の記事を read_file で全文読み込み、修正し、続けて 2 本目を全文読み込み、修正し……と直列に作業を続けます。すると、1 本目・2 本目・3 本目の 「生ファイル全文」と「書き換え差分の巨大ログ」がすべて同じ親コンテキストの履歴(会話ログ)に居座り続ける ことになります。

大規模言語モデル(LLM)の API 通信では、1 ステップ進むごとに「これまでの全履歴」を毎回プロンプトとして再送信します。そのため、ステップ数を NN、1 件あたりの蓄積トークンを TT とすると、総プロンプト通信量は O(N2⋅T)O(N^2 \cdot T) のオーダーで雪だるま式に膨張してしまいます。

さらに、Model Context Protocol (MCP) Official Specification|Tools Schema に準拠する外部ツール定義や長大なツール出力がそのまま親履歴に積み重なると、後半の 4 本目・5 本目を処理する頃にはコンテキストウィンドウが過去の無関係な記事テキストで埋め尽くされます。その結果、いわゆる 「Context Rot(文脈の腐敗・注意力の散漫化)」 が起きて指示抜けやハルシネーションが急増するのです。

子エージェントへの文脈隔離と即時破棄

では、なぜ当ラボの実験 B(5 件バルク一括)ではその逆――すなわち 1 件単独(実験 A)よりも親コンテキストが約 4 割もスリム化する逆転現象 が起きたのでしょうか。実測トークン数の内訳をグラフで見比べると、そのカラクリが一目瞭然となります。

実験A(1件単独)vs 実験B(5件バルク)の親コンテキスト・トークン消費比較
5倍の記事(13ファイル)を処理した実験Bの方が、親エージェントの文脈負荷はすべて約4割減少
① 実験A(1件単独):親の総プロンプト送信量親1人で調査・編集・確認まで全38ステップ・88ツールコールを抱え込んだ結果
543.3 万トークン(5,433,013)親1人で抱え込み
② 実験B(5件バルク):親の総プロンプト送信量編集実務を子3体へ隔離し、親は31ステップ・56ツールコールで統括
294.1 万トークン(−45.9%削減)45.9%軽量化
③ 実験A(1件単独):親のFresh(新規)入力トークン親ログ容量 385.9 KB(初回完了時点でも 33.8 万トークン)
59.2 万トークン(592,385)
④ 実験B(5件バルク):親のFresh(新規)入力トークン親ログ容量 237.2 KB(実験A比でログサイズ −38.5% 軽量化)
34.1 万トークン(−42.4%削減)42.4%削減
⑤ 実験B(参考):子サブエージェント3体合計の総プロンプトFresh入力計 55.5 万トークン・編集完了と同時に独立破棄(親文脈へ混入ゼロ)
268.2 万トークン(独立消化・即時破棄)文脈隔離
※実験Bでは子3体が独立した短いセッションで計268.2万トークンを消化して即破棄したため、親のKVキャッシュ再送が膨らみませんでした

この逆転を生んだ核心技術こそが、「サブエージェントへの文脈隔離(Context Isolation)と完了時の即時破棄(ガベージコレクション)」 です。

💡 なぜ5件バルクの方が親コンテキストが38.5%も軽くなったのか?(3つの構造的理由)
  • 理由①:最もトークンを食う「原稿の行抽出と edit_file 差分」を子エージェントへ完全隔離したため : 実験 A では親自身が対象記事の本文行を取り出し、edit_file の長い Target と Replacement を親の会話履歴に直接刻み込みました。その結果、後半のビルドや検証ステップでも毎回その重い編集テキストが親コンテキストに残り続けました。

  • 理由①の続き(実験 B の独立消化と即時破棄) : 一方、実験 B では 5 記事分の本文抽出と編集(Fresh 入力合計 555,097 トークン・総プロンプト 2,681,695 トークン)を 3 体のサブエージェントがそれぞれの独立した短期メモリ空間で消化し、親には「編集完了サマリー(十数行)」だけを返して子セッション自体は即座に破棄 されました。

  • 理由②:親のステップ数が 38 → 31、ツール呼び出しが 88回 → 56回 へ減ったため : 親自身が細かい行確認や個別編集の試行錯誤を行わずに済んだため、親の Planner 推論ステップ自体が 38 回から 31 回へ 7 ステップ短縮 されました。親の履歴が 237.2 KB とスリムなままステップ数も減ったため、毎ターンの KV キャッシュ再送を含む総プロンプト量が 543.3万 → 294.1万トークン(−45.9%) へと半減近くまで圧縮されたのです。

  • 理由③:1 記事あたりの文脈構造が完全に分離され、記事間の混線(Context Pollution)が物理的に起きないため : 「1 チャットに 5 件まとめると、1 本目の記事内容と 4 本目の記事内容が混ざって変な文章になるのでは?」という懸念も、排他サブエージェント方式なら無縁です。各サブエージェントは割り当てられた 1〜2 記事のテキストしか見ないため、他記事の文脈が混入する余地が構造上ゼロになります。

質問するおじさん

なるほどー!!「1 つのチャットに 5 件まとめて指示する」といっても、親 1 人に全部やらせるんじゃなくて、親は目次と設計図だけ見て、実際の重い原稿読み書きは 3 人の部下(サブエージェント)に別室でやらせて、終わったら部下の作業机ごと片付ける から、親の頭の中(コンテキスト)は 1 件自分で作業した時よりもむしろスッキリ軽くなるんですね!

解説ナビゲーター

その通りです!親と子3体の総プロンプト量をすべて合算しても 294.1万 + 268.2万 = 562.3万トークン ですから、実験 A で 1 記事だけ処理した時の 543.3万トークン とほぼ同じ総トークン量(わずか +3.5% の差)で、5 倍の 5 記事(13 ファイル)を処理し切った 計算になります。これが文脈隔離の凄まじい燃費効率です!

複数チャット同時起動が7分待機を生む罠

ここで、もう 1 つのよくある疑問――「だったら、別々のチャットウィンドウを 5 つ同時に開いて、それぞれで 1 記事ずつ並行実行させれば、人間が分割管理の手間をかけるだけで同じように速くなるのではないか?」 というツッコミについて検証しましょう。

結論から言うと、同じローカルリポジトリ(同一ワークスペース)に対して複数の AI チャットを同時に走らせるのは、最も避けるべきアンチパターン です。実は今回の実験 B の冒頭 7.0分間 のログ自体が、その危険性と待機ロスを見事に証明しています。

同一作業フォルダでのビルドとロック競合

なぜ複数の独立したチャットを同一ワークスペースで同時に走らせると破綻するのでしょうか。理由は、各チャットにいる AI エージェントはお互いの存在を知らないにもかかわらず、ディスク上の「共有リソース(単一障害点)」を奪い合うから です。

💥 複数チャットを同一ワークスペースで同時並行させた時に起きる4大競合
  • ① Git インデックスロック(.git/index.lock)と意図せぬコミット巻き込み : Git Official Documentation|git-commit の仕様上、作業ツリーとステージング領域(Index)はリポジトリごとに 1 つしかありません。チャット A が git add . && git commit を実行した瞬間、チャット B が書きかけだった未完成ファイルまで勝手にコミットに巻き込まれたり、.git/index.lock の競合エラーでデプロイが異常停止したりします。

  • ② 共通ファイル(商品辞書・定数・逆リンク先記事)の「後勝ち上書き(Lost Update)」 : 5 本の記事がそれぞれ別の記事であっても、双方向内部リンクを張る相手のハブ記事や、src/consts.ts、アフィリエイト辞書 src/data/affiliates/ などは共通で更新されます。別チャット同士が同時に編集すると、片方の変更がもう片方に上書き消去されます。

  • ③ 出力ディレクトリ(dist/)の破壊と SFTP 二重転送 : チャット A が本番転送中で dist/ を SFTP アップロードしている最中に、チャット B が astro build を始めて dist/ を一旦消去・再生成すると、本番サーバーへ不完全なビルド成果物が転送される大事故になります。

  • ④ 排他ロックによる長い直列待ち(実測 7.0分 の待機ロス) : 当ラボではこうした破壊事故を防ぐため、デプロイや検問にロック機構を設けています。その結果、実験 B を開始した際、先行していた実験 A の編集〜本番デプロイが終わるまでの 丸々 7.0分間、実験 B はワークスペース保護のために待機 せざるを得ませんでした。もし 5 つの別チャットを同時に立ち上げれば、結局ビルドとデプロイのフェーズで激しいロック待ちの渋滞が起きるうえ、重い Astro 全件ビルドと SFTP 転送を 5 回も無駄に繰り返す ことになります。

運用3方式の速度と安全性マトリクス

ここまでの実測結果をもとに、「1 件 1 チャット直列」「複数チャット同時乱立」「1 チャット排他バルク並列(当ラボ推奨)」の 3 方式を一覧で比較してみましょう。

AIエージェントへの複数タスク指示・3方式の比較マトリクス
VS
約83.5分(遅い)
方式①:1件1チャット直列
  • 処理速度(5 件換算) :1 件 16.7分 × 5 回= 約 83.5分(推論を含む単純換算)。ビルドと実機検証の固定費が 5 回丸々かかる

  • トークン・クォータ効率 :5 回とも親が全工程を抱え込むため、5 セッション合計で約 2,700 万トークン超(推論)を消費

  • ファイル競合リスク :1 件ずつ完了を待ってから次を開くため競合はしないが、人間が 17 分おきに 5 回貼り付ける手間が発生

競合・事故リスク大
方式②:複数チャット同時乱立
  • 処理速度(5 件同時) :編集は並行できても、ビルド・デプロイの排他ロック待ち(実測 1 回あたり 7.0分 等)が連鎖し渋滞

  • トークン・クォータ効率 :5 つの親チャットが個別にフルビルドと検証を 5 回回すため、CPU・SSD 負荷もトークン消費も 5 倍

  • ファイル競合リスク :極めて危険。git commit の巻き込み、逆リンク先記事の上書き消失、dist/ ビルド破壊が頻発

純区間12.0分(推奨)
方式③:1チャット排他バルク並列
  • 処理速度(5 件一括) :純バルク区間 12.0分(2.4分 / 本)。仕上げ 2.4秒・転送 67秒・検証 11秒 が最後 1 回のみで完結

  • トークン・クォータ効率 :子 3 体への文脈隔離により、親コンテキストは −38.5% 軽量化。1 件単独と同等の総通信量で 5 件完遂

  • ファイル競合リスク :完全ゼロ。親が事前に編集対象を排他割り当てし、共通処理(逆リンク注入・コミット)は親が最後に 1 回一括実行

同一ワークスペースでの複数タスク処理は「1チャット排他バルク並列」が速度・安全性・トークン効率のすべてで圧勝

なんでも一括にすれば良いわけではない境界線

ここまで読むと、「1 チャットで 5 件まとめて 7 倍速くなるなら、いっそ 20 件でも 50 件でも 1 チャットに全部詰め込めばもっと速くなるのでは?」 と思われるかもしれません。

しかし、システム工学において「無限にスケールする魔法」は存在しません。実務で多数のバルク処理と大規模監査を回してきた経験から、1 チャットで一括指示してよい上限(スイートスポット)と、あえてチャットを分けるべき例外境界 を明確にお伝えします。

最適バッチサイズが3〜5件に収束する理由

当ラボの結論として、通常の記事改修・SEO 補強・機能修正を 1 チャットでバルク指示する場合の最適バッチサイズは 「1 チャットあたり 3〜5件(軽量な定型チェックでも最大 6〜8件 まで)」 です。これを超えて 15 件・20 件と 1 チャットに詰め込むと、逆に効率が落ちる明確な二律背反(トレードオフ)が存在します。

⚖️ なぜ20件・50件ではなく「1チャット3〜5件」が最適スイートスポットなのか?
  • 限界①:クラウド AI ハーネスの「30 分 / 100 ツールコール」タイムアウト壁 : Antigravity 等の上位エージェント環境では、1 ターンの自律実行が約 30 分またはツール呼び出し 100 回を超えると、API 接続断や Model unavailable による強制停止リスクが急上昇します。5 件バルクなら純実行 12.0分・親ツール 56回 と安全圏のど真ん中で完走できますが、15〜20 件を 1 ターンに詰め込むと後半で時間制限に引っかかりやすくなります。

  • 限界②:サブエージェント並列数とローカル I/O・API レート制限の均衡点 : 同時に起動するサブエージェントは 3〜6体 が最も安定して高速に返ってきます。3 体のサブエージェントに「1 体あたり 1〜2 記事(合計 3〜5 記事)」を割り振ると、各サブエージェントが約 5〜7分 でほぼ同時にゴールするため、待ち時間のムダ(ストラグラー問題)が発生しません。1 体に 5 記事も持たせると、今度はサブエージェント自身のコンテキストが重くなってしまいます。

  • 限界③:最後の Decision 1 検品と Playwright 実機検証の集約コスト : 5 記事であれば、本番転送時の意味一次検問や Playwright の 5 URL 巡回も 11秒 で一瞬で終わります。しかしこれが 30 記事になると、最後の検証ループ自体が長大化し、万が一 1 記事だけフォーマット違反があった際のリトライコストが大きくなります。

質問するおじさん

なるほど!「少なすぎると毎回のビルド固定費(約 80 秒+前後の推論ターン)がもったいないし、逆に 20 件も詰め込むと 30 分の制限時間やサブエージェントの消化不良に引っかかる」から、3〜5 件を 3 班のサブエージェントで割る(1 班 1〜2 件) のが一番気持ちよく 12 分前後で走り切れる黄金比なんですね!

実行前に弾くべきタスクの見極めと直列条件

もう 1 つ、バルク実行で失敗しないための極めて重要な実務ノウハウがあります。それは 「何でもかんでも AI に編集させる前に、最初の事前診断(Phase 1)で『そもそも今いじるべきではないタスク』を正確に切り分けること」、そして 「タスク間に強い依存関係がある場合は無理に並列化しないこと」 です。

実際に今回の実験日(2026 年 11 月 15 日)にも、Search Console の「未インデックス(未登録)一覧」を精査した際、同じ「未登録」に見えても 原因と優先度がまったく異なる 3 つの状態 が混在していました。

🔍 実例:同じ「GSC未インデックス」でも投入前に切り分けるべき状態の違い
  • 最優先で改修すべき本丸(「クロール済み - インデックス未登録」および古参の「検出 - インデックス未登録」) : Google がすでにページを読んだうえで登録を保留している記事(今回の実験 A の対象)や、公開から日数が経過しているのにクローラーが本文を読みに来ていない記事は、検索意図に対する見出し・一次情報の補強や、サイト内の主力記事からの双方向内部リンク注入が直撃する本命ターゲットです。

  • 初期リンク導線の点検だけで十分な新着群(「URL が Google に認識されていません」) : 公開から 1〜3 日しか経っていない新着記事(今回の実験 B で初期被リンク 3〜4 本から主力 8 記事の逆リンクを増強した群)が未登録なのは、主にクローラーの初回巡回タイムラグによるものです。サイトマップ収録と主力記事からの内部リンク導線(目安 4〜6 本)さえ整っていれば、何度も本文を書き直す必要はなく、そのまま自然巡回を待つ(経過観察として過剰な再編集を止める)のが最も経済的です。

さらに、以下のようなケースでは「1 チャット並列バルク」ではなく、あえてチャットを分けるか直列順序を守る 必要があります。

⚠️ バルク並列にせず「直列」または「別チャット」に分けるべき3つの例外条件
  • 例外①:共通の親レイアウト・スキーマ定義(config.ts 等)を破壊的に変更し、その新仕様に合わせて各記事を書き換える場合 : 先にスキーマ変更(先行タスク)が完了していないと、並列サブエージェントが旧仕様と新仕様のどちらで書いてよいか矛盾を起こします。まず基盤変更だけを単独で完了させてから、記事群をバルク並列で流してください。

  • 例外②:1 本あたり 1.5 万字超の新規長文記事をゼロから書き下ろす場合(写真 10 枚超の実機レビュー等) : 新規の大型記事は 1 本だけでも画像変換・EXIF 解析・一次情報裏取り・執筆(Gemini 4 Argon High の Swarm 連携)で十分な密度があります。既存記事の手直し(edit / gsc)は 5 件バルクが最適ですが、ゼロからの大型新規執筆は 1 チャット 1 本(または排他分割した 2 本まで)に集中させる方が品質が高まります。

  • 例外③:まったく無関係な別プロジェクトや、数日がかりの巨大アプリ新造(/teamwork 領域) : ブログ記事の SEO 改修と、Swift ネイティブアプリの UI 大改造のように、参照する知識ベースもビルドコマンドも完全に異なるタスクを 1 チャットに混ぜると、親の判断分岐が無駄に複雑化します。同じワークフロー(例:GSC 改善 5 本、表記ゆれ修正 5 本、アフィリエイト追加 5 本)で揃えてバルク化するのが鉄則です。

高速一括処理を支えるRust基盤と64GB母艦

今回の実験 B において、5 記事(13 ファイル)のバルク処理が 「親・子ともに read_file 0 回」「3 班並列でも DB 競合ゼロ」「一括 finish が 2.4 秒」 という圧倒的なスピードで完走できた背景には、AI のプロンプトだけでなく、それを下支えする Pure Rust 製のローカル CLI 基盤 と 64GB メモリ+16GB RAMDisk の母艦ハードウェア があります。

排他制御とミリ秒抽出を担うRust設計

サブエージェントを 3 体同時に走らせるということは、ローカル環境では複数のプロセスが同時に SQLite データベースへクエリを投げ、同時にファイルシステムへアクセスすることを意味します。

もしここが素朴なシェルスクリプトやロック制御のない JSON ファイル読み書きだった場合、3 体のサブエージェントが同時に動いた瞬間に database is locked エラーやファイル破損が発生してしまいます。当ラボの kb-search および gemini-gate が並列バルク実行でビクともしない理由は、以下の 2 つのシステム設計にあります。

🦀 並列バルク実行をミリ秒で支える SQLite WAL モードと Rust 排他制御
  • SQLite の WAL(Write-Ahead Logging)モードと mmap による並列読み取りの完全ノンブロッキング化 : SQLite Official Documentation|Write-Ahead Logging (WAL) が定義する PRAGMA journal_mode = WAL; を有効化することで、書き込みトランザクションと複数の読み取りトランザクションが互いにブロックしなくなります。さらに mmap_size(メモリマップド I/O)を組み合わせることで、3 体のサブエージェントが同時に kb-search tree を連打しても、OS のメモリキャッシュ上から 実測 2〜11ms で同時並行に応答が返ります。

  • Rust の型安全なスレッド同期(Mutex)と単一トランザクション集約 : 並列スレッド間で共有状態を扱う箇所や、最後の gemini-gate finish で 5 記事+逆リンク先 8 記事(計 13 ファイル)を一括更新するフェーズでは、Rust Official Documentation|std::sync::Mutex 等の同期プリミティブと Rayon 並列イテレータを用い、読み取り・解析は 12 スレッド並列で行いつつ、ファイル書き出しと SQLite 同期は競合ゼロで原子的に処理しています。だからこそ、13 ファイルの整形・リンク注入・DB 更新がわずか 2,427.9ms(2.4秒) で安全に完了するのです。

AI エージェントの指示待ち時間やトークン消費を根本から減らすには、プロンプトの工夫だけでなく、このように「AI が呼ぶローカルツール自体を Rust と SQLite で高速・並列対応させる」アプローチが極めて有効です。システムプログラミングや並列安全性の基礎から実践までを体系的に手元に置いて学びたい方には、以下の定番解説書が長く役立ちます。

オライリー・ジャパン『プログラミングRust 第2版』

オライリー・ジャパン『プログラミングRust 第2版』

並列稼働でもスワップゼロを守る64GB環境

そしてソフトウェア基盤と同じくらい重要なのが、「親エージェント + 3 体の並列サブエージェント + 16GB RAMDisk + SQLite メモリマップ + Astro 全ページビルド + Playwright ヘッドレス Chromium」を同時に動かしても、1 バイトも SSD スワップを起こさない物理メモリ容量(64GB)」 です。

もしメモリ 8GB や 16GB の一般的な PC で 5 件バルク並列を実行すると、サブエージェントとビルドプロセス、ヘッドレスブラウザが同時にメモリを要求した瞬間にユニファイドメモリ/物理メモリが枯渇し、内蔵 SSD へのスワップ(仮想メモリ書き出し)が多発して、せっかくの 2.4 秒・67 秒という高速パイプラインが数分間のフリーズに変わってしまいます。

当ラボでは、中古Intel Macの完全初期化とデータ移行|消せない「user(SecureToken)」解決とOS更新対策 で解説した手順でクリーン構築した 64GB メモリ搭載母艦の上に、Macに16GB RAMDiskを自動構築する方法|64GBメモリで内蔵SSD寿命を守りビルドを爆速化する設計 で公開している 16GB の APFS RAMDisk を常駐させ、gemini-gate の常駐バイナリやビルド一時ファイル、ブラウザキャッシュをすべて RAM 上で処理しています。

これから AI エージェントの並列バルク運用を本格的に快適化したい方のために、現行の新品 Apple シリコン環境と、圧倒的コストパフォーマンスを誇る 5K 中古 Intel iMac 増設環境の 2 つの選択肢と、1 時間あたりの投資回収試算(推論を含む試算)を整理しました。

🖥️ 並列サブエージェント&RAMDiskをスワップゼロで回す64GB母艦の2大選択肢と時間単価試算
  • 選択肢①:最新 Apple シリコンで長く戦うなら「Mac mini(M4 Pro・64GB ユニファイドメモリ構成)」 : 省電力・静音でありながら、M4 Pro の圧倒的なマルチコア性能と広帯域な 64GB ユニファイドメモリにより、Astro の大型ビルドや Rust コンパイル、ローカル LLM 補助まで最速クラスで処理できます。

  • 選択肢①の時間単価試算(推論) : 仮に約 30 万円の構成を 4 年間(1,460 日・毎日 3 時間 AI 開発に活用=計 4,380 時間)運用した場合、1 時間あたりの機材コストは約 68.5円 / 時間(1 日あたり約 205円)[推論を含む日割り・時間単価試算]となり、今回のバルク化で 5 件あたり約 71 分(83.5分 → 12.0分)短縮できる時間価値を考えれば、数ヶ月で十分に元が取れる投資です。

  • 選択肢②:予算 10 万円前後で 27 インチ 5K 画面+64GB メモリを手に入れるなら「iMac 27 インチ(2020 年最終 Intel モデル)+ DDR4 64GB 自己増設」 : 現在の Mac シリーズで唯一「背面のハッチをワンタッチで開けて、市販の SO-DIMM メモリを自分で安価に 64GB〜128GB まで増設できる」名機です。中古本体(約 8〜11 万円前後)に Crucial 製の DDR4-2666 64GB キット(32GB×2 枚)を組み合わせれば、美麗な 5K ディスプレイ込みの総額約 11〜14 万円前後で 64GB+16GB RAMDisk 母艦が完成します。

  • 選択肢②の時間単価試算(推論)と増設時の注意点 : 3 年間(計 3,285 時間)運用した場合の 1 時間あたりコストは約 33〜43円 / 時間[推論を含む日割り・時間単価試算]という驚異的な低コストを実現できます(※この DDR4 SO-DIMM メモリは 2019/2020 年モデルの 27 インチ Intel iMac 等のメモリスロット搭載機専用であり、Apple シリコン搭載 Mac には後付け増設できませんのでご注意ください)。

Apple Mac mini(M4 Pro 等 Appleシリコン Pro系チップ・64GBユニファイドメモリ構成)

Apple Mac mini(M4 Pro 等 Appleシリコン Pro系チップ・64GBユニファイドメモリ構成)

【中古・整備済品】Apple iMac 27インチ Retina 5K (2020年モデル / Intel最終世代・メモリ自己増設対応)

【中古・整備済品】Apple iMac 27インチ Retina 5K (2020年モデル / Intel最終世代・メモリ自己増設対応)

【Intel Mac増設用】Crucial iMac 27インチ(2019/2020)・ノートPC用 メモリ DDR4-2666 SO-DIMM (16GB×2 / 32GB×2)

【Intel Mac増設用】Crucial iMac 27インチ(2019/2020)・ノートPC用 メモリ DDR4-2666 SO-DIMM (16GB×2 / 32GB×2)

まとめ:AIへの指示方式の選び方と実践手順

今回の「1 件単独チャット実行(実験 A)」と「1 チャット 5 件バルク一括実行(実験 B)」の実稼働トランスクリプト比較によって明らかになった結論と、明日から使える判断基準を整理します。

✅ AIエージェントへの複数タスク指示・最終判断チェックリスト
  • 1 チャットで「3〜5 件バルク一括(排他サブエージェント並列)」にすべきケース(推奨) : Google Search Console に基づく複数記事の SEO 改善・見出し補強・内部リンク強化(/gsc-fix 等)や、複数の既存記事・複数コンポーネントに対する同種のリライト、表記統一、アフィリエイト追加(/edit-post 等)は、編集対象ファイルを事前に排他分割し、最後の検問・ビルド・デプロイ・実機検証を 1 回にまとめるバルク方式が最適です。

  • バルク一括方式で得られる実測効果 : 1 記事あたりの処理時間が 16.7分 → 2.4分(純バルク区間・約 7.0 倍高速) に短縮されるだけでなく、子エージェントへの文脈隔離によって親コンテキスト容量も −38.5% 軽量化 されます。

  • 1 チャット 1 件(または直列順序)に分けるべきケース : 1 本 1.5 万字規模の新規大型記事のゼロからの書き下ろし(写真 10 枚超の実機レビュー等)や、共通のデータベーススキーマ・コアレイアウトを先に破壊的変更してから下位ファイルを修正する強い前後依存タスクは、無理に並列化せず単独または直列順序で実行してください。

  • 事前診断でスキップ(除外)すべきケース : 公開から 1〜2 日しか経過しておらず、単にクローラーの初回巡回待ちに過ぎない新規記事は、バルク改修の対象から外して経過観察とするのが最も経済的です。

  • 絶対にやってはいけないアンチパターン : 同一のローカルリポジトリ(同じワークスペース)に対して複数のチャットウィンドウを同時に開き、排他制御なしで並行ビルド・並行コミットを走らせること(実測 7.0分 のロック待機や Git 巻き込み・dist/ 破壊の原因になります)。

最適バッチサイズを設計させるプロンプト

最後に、読者の皆さまがご自身のブログ運営やソフトウェア開発プロジェクトにおいて、「自分の環境とタスク内容では、何件ずつ 1 チャットにまとめてどのようにサブエージェントへ排他分担させるのが最も速くて安全か?」を、最上位の推論力を持つ Gemini 4 Argon または Gemini 4 Carbon に直接診断・設計させるためのコピペ用プロンプトをご用意しました。

以下のコードブロックをコピーし、お使いの AI エージェントに貼り付けてご活用ください。

以下の実測検証記事の内容(1件単独チャット16.7分 vs 1チャット5件バルク並列で純区間12.0分・1件2.4分化、および親コンテキスト38.5%軽量化とGit/ビルド競合回避の仕組み)を基準として読み込んでください。
https://lab.chihouzakki.com/blog/review/ai-chat-single-vs-bulk-command-benchmark/

私が現在抱えている以下の複数タスクと開発環境において、
1. 実行前にスキップ(除外)すべきタスクはあるか
2. 先に単独(直列)で片付けるべき共通基盤タスクはあるか
3. 残りのタスクを「1チャット何件ずつのバルク」に分け、何体のサブエージェントへどのファイルを排他割り当てすれば競合ゼロ・最小トークンで完遂できるか
4. 最後に1回だけまとめて実行すべき検問・ビルド・検証コマンドの手順
を具体的な実行プランとして設計してください。

【私の現在の環境とやりたい複数タスク一覧】:
(ここに修正したい記事やファイル、タスクを箇条書きで貼り付けてください)
ノルウェージャンフォレストキャット

「1 件ずつ別チャットで頼むのが丁寧で安全」という思い込みを捨てて、「事前診断は親が 1 回、編集は 3 班のサブエージェントで排他並列、最後の仕上げ検問・ビルド・ブラウザ検証は親が 1 回で一括完遂」 に切り替えるだけで、時間は最大 7 分の 1、親の頭の中も約 4 割スッキリ軽くなるんでちぃ!ぜひ自分の環境でも 3〜5 件バルクの爆速体験を試してみてほしいでちぃ〜!

5件バルク一括処理であっという間に仕事が終わって気持ちよさそうに眠る猫様