記事一覧
MCPトークン

MCPの「ポーリング税」:長時間ツールの状態確認がMCPトークン消費を増やす仕組みと、Tasks・ロングポーリング・コード実行による4つの安い待ち方【2026年版】

長時間かかるMCPツールをモデルがポーリングすると、確認のたびにコンテキスト全体を読み直します。Claude Sonnet 5.5で試算すると60回で1,000ジョブあたり254.23ドル。MCP Tasks、コード実行、ロングポーリング、5分キャッシュの落とし穴と1時間TTLを比較します。

最終更新:2026年11月22日 / 対象:MCP Tasks拡張(io.modelcontextprotocol/tasks、2026-07-28リリース)、Claude CodeのMCPタスク(v2.1.304以降、パブリックベータ)と自動バックグラウンド化、Claude APIのプロンプトキャッシュ(5分・1時間TTL)、Claude Sonnet 5.5の料金

ビルド、エクスポート、クロール、レポート生成のように時間のかかるMCPツールは、「start_job でジョブIDを受け取り、get_job_status で終わったか確認する」という2つのツールの組で作られることがよくあります。仕組みとしては問題ありません。ただし、状態確認(ポーリング)をモデル自身が行うと、確認1回ごとにモデルへのリクエストが1回発生し、そのたびにツール一覧を含むコンテキスト全体を読み直します。この記事では、この「ポーリング税」がMCPのトークン消費(MCP Token)をどれだけ増やすかを計算方法つきで試算し、待ち方を変える4つの方法(MCP Tasks拡張、サーバー側のロングポーリング、コード実行の中で待つ、キャッシュを意識したポーリング)を比較します。

この記事の「トークン」はLLMのトークン(コンテキストと課金)のことで、APIキーやOAuthのアクセストークンのことではありません。

結論(30秒で読める要約)

  • モデルによるポーリングは、1回でリクエスト1回分の費用がかかります。 状態の結果は80トークンでも、それを読むリクエストはシステムプロンプト、ツール定義、会話履歴をすべて送り直します。私の試算(コンテキスト30,286トークン、Claude Sonnet 5.5)では、1回あたりキャッシュありで約0.0039ドル、キャッシュなしで約0.061ドルです。
  • 費用はジョブの「長さ」に比例します。 6分かかるジョブを60回続けて確認すると、1,000ジョブあたりキャッシュありで254.23ドル、キャッシュなしで4,124.52ドルかかります。しかも60回分の「実行中です」という結果、約7,700トークンが履歴に残ります。
  • キャッシュの寿命より間隔が長いポーリングが一番割高です。 Anthropicのキャッシュは既定で5分です。1時間のジョブを10分おきに6回確認すると、毎回コンテキスト全体をキャッシュに書き直すため、1,000ジョブあたり462.17ドルになります。1時間TTLを使うと142.08ドルです。
  • 待つ役目をモデルから外すのが根本的な対策です。 MCP Tasks拡張ならポーリングするのはクライアントで、モデルのリクエストは1回、1,000ジョブあたり3.85ドルです。サーバー側のロングポーリング(wait_seconds: 60)なら60回が7回になり27.25ドル、コード実行でジョブの開始から完了待ちまでを1本のスクリプトにすると4.73ドルです。
  • Claude Codeはv2.1.304からMCPタスクに対応しています(MCPのドキュメントではパブリックベータ)。Claude Code自身が tasks/get で状態を確認し、その間もClaudeは作業を続けます。他のクライアントは未対応のこともあるので、代わりの手段も用意しておきます。

目次

  1. MCPの「ポーリング税」とは
  2. モデルによるポーリングが高くつく4つの理由
  3. 試算の前提と計算式
  4. 試算結果:6分のジョブを7通りの待ち方で比較
  5. 方法1:MCP Tasks(モデルではなくクライアントが確認する)
  6. 方法2:サーバー側のロングポーリング
  7. 方法3:コード実行の中で待つ
  8. 方法4:モデルが確認するしかない場合はキャッシュを意識する
  9. クライアント・状況別のおすすめ
  10. チェックリスト
  11. よくあるハマりどころ
  12. NodeFlareならこう解決できる
  13. よくある質問

1. MCPの「ポーリング税」とは

MCPのポーリング税とは、長時間かかるツールの完了をエージェントが待つ間に消費されるトークンのことです。中身は「終わった?」と聞くだけのリクエストで、次の3つからなります。確認のたびに読み直すコンテキスト(システムプロンプト、ツール定義、履歴)、確認そのもののツール呼び出しと結果、そしてその確認が履歴に残り、以降のリクエストで読み直され続ける分です。

ポーリング税が発生するのは、モデルが待つ役目を担っている場合です。

構成 待つのは誰か ポーリング税
start_job と get_job_status を用意し、モデルが状態確認を繰り返す モデル 大きい。ジョブが長いほど増える
同じツールで、エージェントを定期的に起動して確認する(「10分後に確認」) モデル(キャッシュ切れをまたぐ) 1回あたりが最も高い
完了まで返らない1回のツール呼び出し MCPクライアント なし。ただしタイムアウトにかかりやすい(タイムアウトの解説)
MCP Tasks拡張 MCPクライアント(tasks/get) ほぼゼロ
待つ処理を含むコード実行のスクリプト サンドボックス リクエスト1回分

ツール呼び出しが途中で切れないかはタイムアウトの記事で扱いました。この記事は、ジョブIDで待つ方式に切り替えたあと、トークンでいくらかかるかの話です。

2. モデルによるポーリングが高くつく4つの理由

ポーリングはサーバーにとっては軽い処理ですが、モデルにとっては高い処理です。理由は4つあります。

  1. 確認1回がリクエスト1回です。 LLMのAPIは状態を持たず、毎回プロンプト全体を送ります。Anthropicの料金ページでは、ツール名・説明・スキーマを含む tools パラメータがリクエストごとに課金されます。50トークンの呼び出しと80トークンの結果が、3万トークンのコンテキストに乗って送られます。
  2. モデルは「待つ」ことができません。 ツールの説明に「10秒ごとに get_job_status を呼ぶこと」と書いても、モデルが10秒待つわけではありません。自分のターンが終わるとすぐ次を呼ぶので、確認の回数は意図した間隔ではなく、エージェントのループが回る速さで決まります。
  3. 確認の記録が履歴にたまります。 確認するたびに tool_use ブロックと結果が会話に追加されます。60件の「running」は、圧縮か削除をしない限り、その後のすべてのリクエストで読み直されます。
  4. キャッシュには寿命があります。 Anthropicのプロンプトキャッシュのドキュメントでは、キャッシュの寿命は既定で5分で、キャッシュが使われるたびに追加料金なしで延長されます。続けて確認している間はキャッシュが保たれますが、5分以上空くとキャッシュが切れ、コンテキスト全体をキャッシュ書き込みの料金(Sonnet 5.5で100万トークンあたり2.50ドル)で書き直すことになります。

3. 試算の前提と計算式

この記事の数値はすべて私が計算したもので、実測ではありません。費用に含めたのは「待っている間」のリクエストだけです。ジョブを始める呼び出しから、モデルが結果をコンテキストに受け取るまでを数えます。その結果を使う次のリクエストはどの方法でも同じなので除いています。

前提 値
モデル Claude Sonnet 5.5:入力2ドル、5分キャッシュ書き込み2.50ドル、1時間キャッシュ書き込み4ドル、キャッシュヒット0.10ドル、出力10ドル(100万トークンあたり、Anthropicの料金ページ、2026年11月22日時点)
ツール定義 20,000トークン
システムプロンプト+ツール使用のシステムプロンプト 2,000+286トークン
ジョブ開始時点の履歴 8,000トークン
待ち始めのコンテキスト(C₀) 30,286トークン
確認1回あたりの呼び出し(出力)/結果 50/80トークン。確認ごとに履歴が130トークン増える
ジョブの所要時間 6分
続けて確認した場合の回数 60回(約6秒に1回。ループの速さの仮定で、実測ではない)

k回目(k = 0, 1, …, n−1)のリクエストの費用は、Cₖ = C₀ + 130k として次のとおりです(100万トークンあたりの単価で計算)。

  • キャッシュあり:Cₖ × 0.10 + 130 × 2.50 + 50 × 10
  • キャッシュなし:Cₖ × 2 + 50 × 10
  • キャッシュ切れ(間隔が5分超):Cₖ × 2.50 + 50 × 10

キャッシュありの1回目は 30,286 × 0.10 + 130 × 2.50 + 50 × 10 = 3,853.6 で、100万で割ると0.00385ドルです。計算に使ったスクリプトは4章の最後に載せています。

4. 試算結果:6分のジョブを7通りの待ち方で比較

待ち方 待つ間のモデルのリクエスト数 1,000ジョブあたりの費用(Sonnet 5.5) 履歴に残る量
A. モデルが続けて確認、キャッシュなし 60 4,124.52ドル 約7,800トークン
B. モデルが続けて確認、キャッシュあり 60 254.23ドル 約7,800トークン
C. 1時間のジョブを10分おきに確認、5分キャッシュ(毎回切れる) 6 462.17ドル 約800トークン
D. Cを1時間TTLのキャッシュで 6 142.08ドル 約800トークン
E. サーバー側ロングポーリング(wait_seconds: 60) 7 27.25ドル 約900トークン
F. コード実行:1本のスクリプトで開始から完了待ちまで 1 4.73ドル 約200トークン
G. MCP Tasks:クライアントが tasks/get で確認 1 3.85ドル 約130トークン

表から読み取れることは次のとおりです。

  • キャッシュは必要ですが、それだけでは足りません。 続けて確認する場合、キャッシュで4,124.52ドルが254.23ドルになりますが、それでもTasksの66倍です。
  • 間隔が長い確認ほど、1回あたりは高くなります。 CはBの10分の1の回数なのに、Bより高くつきます。毎回約3万トークンを切れたキャッシュに書き直すためで、1回あたり0.077ドルと、Bの0.0039ドルの約20倍です。
  • 定期的な確認には1時間TTLが手軽で効きます。 最初の書き込みは入力の2倍(100万トークンあたり4ドル)ですが、1時間以内の確認はキャッシュから読めます。
  • 履歴に残った分は「2つ目の請求」です。 Bでは約7,700トークンの確認記録が残り、その後のリクエストで読み直されます。その後20リクエスト続くと約15万3千トークン分のキャッシュ読み込みで、1,000ジョブあたり約15ドルが上乗せされます。
  • ジョブが長いほど直線的に悪化します。 ループの速さが同じなら、12分のジョブではBは2倍以上になります。Tasksとコード実行の行は変わりません。

試算に使ったスクリプトです。自分の数値に置き換えて使えます。

IN, W5, W1, R, OUT = 2.0, 2.5, 4.0, 0.10, 10.0   # Sonnet 5.5、100万トークンあたりのドル
C0, STEP, O = 30_286, 130, 50                     # コンテキスト、確認ごとの履歴増加、確認ごとの出力

def wait_cost(n, mode="cached"):
    total, ctx = 0.0, C0
    for k in range(n):
        if mode == "cached":
            total += ctx * R + STEP * W5 + O * OUT
        elif mode == "uncached":
            total += ctx * IN + O * OUT
        elif mode == "expired":                    # 間隔が5分超
            total += ctx * W5 + O * OUT
        elif mode == "ttl_1h":
            total += (ctx * W1 if k == 0 else ctx * R + STEP * W1) + O * OUT
        ctx += STEP
    return total / 1e6 * 1000                       # 1,000ジョブあたりのドル

print(wait_cost(60), wait_cost(60, "uncached"), wait_cost(7))   # 254.23 4124.52 27.25

5. 方法1:MCP Tasks(モデルではなくクライアントが確認する)

MCP Tasks拡張を使うと、状態確認の役目がモデルからMCPクライアントに移ります。モデルはツールを1回呼ぶだけで、クライアントがモデルのコンテキストに入らないプロトコルのメッセージで状態を確認し、結果は1回だけ届きます。

拡張の仕様(io.modelcontextprotocol/tasks)による流れは次のとおりです。

段階 内容
利用の宣言 クライアントはリクエストごとに _meta のクライアント機能で拡張を宣言し、サーバーは capabilities.extensions で対応を示す
開始 時間のかかる tools/call に対し、サーバーは resultType: "task" と taskId、status: "working"、ttlMs、pollIntervalMs を返す
待機 クライアントが pollIntervalMs に従って tasks/get で完了を確認する。購読したクライアントには、サーバーが notifications/tasks を送ることもできる
完了 状態が completed・failed・cancelled(終了状態)になる。input_required は、先にサーバーへの入力が必要という意味
取り消し tasks/cancel は協調的な取り消しで、サーバーは受け付けを返すだけでよい

Tasksは中核のMCP仕様ではなく拡張で、拡張を宣言していないクライアントにサーバーがタスクを返すことは禁止(MUST NOT)されています。そのため、宣言したクライアントにはタスクを返し、それ以外には通常の結果かジョブIDを返す、という切り分けがきれいにできます。

クライアントの対応状況。 Claude CodeのMCPのドキュメントでは、MCPタスクはClaude Code CLIのパブリックベータで、v2.1.304以降が必要とされています。ドキュメントによると、Claude Codeは自分で tasks/get を送って状態を確認し(サーバーが pollIntervalMs を返さない場合は既定で2秒ごと)、サーバーがジョブを受け付けた時点でツール呼び出しが返るため、その間もClaudeは作業を続けます。他のクライアントで使う前に対応状況を確かめてください。すべてのツール呼び出しを「完了まで待つもの」として扱うクライアントもまだ多くあります。

トークンへの効果。 モデルが払うのはツール呼び出し1回と最終結果だけで、私の試算では1,000ジョブあたり3.85ドルです。ジョブがどれだけ長くても変わりません。確認自体はなくなりませんが、クライアントとサーバーの間のプロトコル通信になるので、LLMのトークンとしては課金されません。

6. 方法2:サーバー側のロングポーリング

クライアントがTasksに対応していないなら、状態確認の呼び出しをサーバー側で待たせます。ジョブが終わるか wait_seconds が過ぎるまで返らない get_job_status にすると、6分のジョブでは60回の確認が7回になり(私の試算で1,000ジョブあたり254.23ドル→27.25ドル)、どのMCPクライアントでも使えます。

MCP TypeScript SDK(registerTool とzodのスキーマ)で書いた例です。ジョブの保存先は自分のキューに合わせて変えてください。

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { z } from "zod";

const server = new McpServer({ name: "jobs", version: "1.0.0" });
const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));

server.registerTool(
  "get_job_status",
  {
    description:
      "Wait up to wait_seconds for a job started with start_export, then return its status. " +
      "Call again only if status is still 'running'. Do not call it in a tight loop.",
    inputSchema: {
      job_id: z.string(),
      wait_seconds: z.number().int().min(0).max(60).default(60),
    },
  },
  async ({ job_id, wait_seconds }) => {
    const deadline = Date.now() + wait_seconds * 1000;
    let job = await jobs.get(job_id);                 // 保存先: { status, url?, error? }
    while (job.status === "running" && Date.now() < deadline) {
      await sleep(2000);
      job = await jobs.get(job_id);
    }
    // 結果は短く、最終状態だけにする
    const text = job.status === "done" ? `done: ${job.url}`
      : job.status === "failed" ? `failed: ${job.error}`
      : "running";
    return { content: [{ type: "text", text }], isError: job.status === "failed" };
  }
);

wait_seconds は経路上のどのタイムアウトよりも短くします。プロキシやロードバランサー(100秒で無通信のリクエストを切るものもあります)、クライアントのツールのタイムアウト、そしてClaude Codeの自動バックグラウンド化のしきい値です。Claude CodeのMCPのドキュメントでは、メインの会話で2分を超えて実行中のMCP呼び出しはバックグラウンドに移され、このしきい値は CLAUDE_CODE_MCP_AUTO_BACKGROUND_MS で変えられるとされています。上限を60秒にしておけば、一般的な構成ではどれにもかかりません。

7. 方法3:コード実行の中で待つ

コード実行(コードモード)では、モデルがジョブの開始から完了待ちまでを1本のスクリプトに書き、最終結果だけを返します。状態確認はすべてサンドボックスの中で行われるので、モデルが払うのはリクエスト1回と短いスクリプトだけです。私の試算では1,000ジョブあたり4.73ドルでした(コードの出力120トークン、戻り値80トークン)。

const { job_id } = await tools.start_export({ report: "q4-sales" });
let s = { status: "running" };
for (let i = 0; i < 9 && s.status === "running"; i++) {
  s = await tools.get_job_status({ job_id, wait_seconds: 60 });  // 6章のロングポーリング
}
return s;   // モデルに届くのはこれだけ

うまくいくかどうかは2つの条件で決まります。

  • サンドボックスの実行時間の上限が、ジョブより長いこと。 6分のジョブなら360秒を超える上限が必要です。
  • すぐ返る状態確認をループで連打しないこと。 1回の実行で呼べるツールの回数に上限があると、数秒で使い切ります。6章のロングポーリングと組み合わせれば、呼び出しごとにサーバーが待つので、数回の呼び出しでジョブ全体をカバーできます。

コード実行がどんな場合に元が取れるかは、コード実行の損益分岐の解説にまとめています。ジョブの完了待ちは、途中の結果がまったく不要なので、コード実行が最もわかりやすく効く例の1つです。

8. 方法4:モデルが確認するしかない場合はキャッシュを意識する

サーバーもクライアントも変えられないこともあります。その場合は、確認1回あたりの費用を下げます。

対策 私の試算での効果
プロンプトキャッシュを確実に効かせる(ツールとシステムプロンプトの後ろに区切り) 続けて確認する場合:1,000ジョブあたり4,124.52ドル→254.23ドル
5分より間隔が空く確認には1時間TTL("ttl": "1h")を使う 6回の確認:462.17ドル→142.08ドル
状態の結果を極力短くする(running/done: <URL>)。進捗ログは返さない 確認ごとの履歴の増加(130トークン)を減らす
「N回確認しても終わらなければジョブIDを報告して止める」と指示する 最悪の場合の上限を決められる
古い状態確認の結果を削除する(コンテキスト編集や圧縮) 以降のリクエストで読み直す分をなくす
長い待機はサブエージェントに任せ、結果だけを返させる 確認のたびに読み直すのが小さいコンテキストになる

同じ仕組みは「順番に呼ぶたびにプレフィックス全体を送り直す」という形で並列呼び出しの記事でも説明しています。ポーリングはその極端な例で、往復しても何の作業も進みません。

9. クライアント・状況別のおすすめ

状況 おすすめ 代わりの手段
Claude Code v2.1.304以降で、サーバーを自分で直せる MCP Tasks 古いバージョン向けにロングポーリングのツール
どのクライアントでも使いたい。サーバーは直せる ロングポーリングの get_job_status(wait_seconds は60以下) 短い状態テキストと、説明文での回数上限
エージェントにコード実行のツールがある 開始とロングポーリングを1本のスクリプトに ロングポーリングのツール
すぐ返る状態確認しかない他社製のサーバー コード実行かサブエージェント キャッシュを意識した確認(8章)
エージェントを定期的に起動して確認する 1時間TTLのキャッシュ。1回の起動で確認は1回 Webhookか、Tasks対応のサーバーを依頼する

10. チェックリスト

  • [ ] 長いジョブ1件で、モデルのリクエストが今何回発生しているか把握している(状態確認ツールの tool_use を数える)
  • [ ] 対応できるサーバーは、Tasks拡張を宣言したクライアントにタスク(resultType: "task")を返している
  • [ ] 状態確認のツールは wait_seconds を受け取り、サーバー側で待つ。上限は一番短いタイムアウトより短い
  • [ ] 状態の結果は短く、最終状態だけを返す
  • [ ] ツールの説明に、呼ぶ頻度とやめる条件を書いている
  • [ ] プロンプトキャッシュが効いており、確認のリクエストで cache_read_input_tokens が0より大きい
  • [ ] 5分より間隔が空く確認には1時間TTLを使っている
  • [ ] ジョブ完了後、古い状態確認の結果を削除または圧縮している
  • [ ] 変更の前後で、1ジョブあたりの費用を比べた

11. よくあるハマりどころ

症状 原因 対処
エクスポート1件が、セッションの残り全部より高くつく すぐ返る状態確認を、モデルが何十回も呼んだ サーバー側で待つか、Tasksを使う
説明に「10秒ごと」と書いたのに数秒おきに呼ばれる モデルは待てず、ターンが終わるとすぐ呼ぶ サーバー側で待たせる(wait_seconds)
1時間ごとの確認は1回の呼び出しなのに高い 5分でキャッシュが切れ、毎回コンテキストを書き直している "ttl": "1h" を使うか、Tasks対応のクライアントにする
Claude CodeではTasksが動くが、別のクライアントでエラーになる そのクライアントは拡張を宣言しておらず、タスクを返してはいけない そのクライアントには通常の結果かジョブIDを返す
ロングポーリングの呼び出しが100秒前後で失敗する プロキシやロードバランサーの無通信の上限 wait_seconds を60以下にする
Claude Codeでロングポーリングの呼び出しがバックグラウンドに移る 2分の自動バックグラウンド化のしきい値を超えた 待ち時間を短くするか、CLAUDE_CODE_MCP_AUTO_BACKGROUND_MS を調整する
コード実行のスクリプトがツール呼び出し回数の上限で止まる すぐ返る状態確認をループで連打した ロングポーリングのツールを数回呼ぶ形にする
ジョブが終わってもその後のリクエストが高いまま 何十件もの状態確認の結果が履歴に残っている ツールの結果を削除するか、圧縮する

12. NodeFlareならこう解決できる

NodeFlareはMCP専用のホスティングです。GitHubリポジトリのMCPサーバーを認証つきのHTTPSエンドポイントとして動かし、プロキシ側にサーバーごとの設定があり、モデルが読む内容を変えられます。どれもサーバーのコードを変える必要はありません。この記事で挙げた課題ごとに対応する機能を紹介します。

課題1:モデルがジョブの状態確認を何度も繰り返す(2章・4章)。 コード実行(tool_code_mode)を有効にします。サーバーは run_code と search_tools を公開し、モデルは tools.start_export(...) と状態確認のツールを呼ぶJavaScriptを1本書き、NodeFlareがそれをサンドボックスで実行します。状態確認はすべてスクリプトの中で行われ、会話に入るのは戻り値だけです。4章のFのケースにあたります。実行は分離されたDenoのサブプロセスで行われ、ファイルシステム・環境変数・プロセス起動は使えず、ネットワークはプロキシのコールバック先に限られます。既定値は実行時間の上限600秒(変更可)、1回の実行あたりのツール呼び出し50回まで、V8ヒープ128MBです。6章のロングポーリングのツールと組み合わせれば、10分弱までのジョブを数回の呼び出しで1回の実行に収められます。

課題2:確認のたびに大きなツール一覧を読み直す(3章)。 tool_search_mode を有効にします。NodeFlareは tools/list の一覧を search_tools(query) と call_tool(name, args) の2つのメタツールに置き換えるので、サーバーのツールがいくつあっても、確認のたびに読み直すツール定義は小さいままです。検索は既定では字句検索で、GEMINI_API_KEY を設定するとセマンティック検索になり、失敗した場合は字句検索に戻ります。

課題3:待っているだけのエージェントが、使わないツールまで抱えている。 tool_list_filter_by_scope を有効にし、待機用のエージェント(またはサブエージェント)に、ジョブ用のツールだけに絞ったAPIキー(例:tools:call:start_export と tools:call:get_job_status)を渡します。tools/list はそのツールだけを返し、スキーマは変わりません。

課題4:他社製のジョブ用サーバーの説明文が長い。 tool_schema_slim は500文字を超えるツールの説明を(UTF-8を壊さずに)切り詰め、名前と入力スキーマはそのまま残します。

NodeFlareはこれらの設定によるトークン削減率を公表していません。3章の前提だけを使った計算例を示すと、キャッシュありの60回のポーリングを1回のコード実行に置き換えると、待つ間の費用は1,000ジョブあたり254.23ドルから4.73ドルになります。コードモードのツールや検索の呼び出し自体にもトークンはかかるので、自分のサーバーで変更の前後を測ってください。

始め方:

  1. NodeFlareのダッシュボードでMCPサーバーのGitHub URLを貼り付けます。ランタイム、パッケージマネージャー、起動コマンドは自動で検出・入力されます。
  2. デプロイしたら tool_code_mode を有効にします(必要に応じて tool_search_mode や tool_list_filter_by_scope も)。
  3. クライアントの接続先を https://<your-server>.nodeflare.tech/mcp にし、Authorization: Bearer <NodeFlareのAPIキー> を付けます。

MCPサーバー1つまでは無料で試せます(Freeプラン:サーバー1つ、月30 GB-hoursのコンピュート)。→ nodeflare.techで始める

13. よくある質問

MCPツールのポーリングはトークンを消費しますか?

モデルが確認する場合は消費します。状態確認は1回ごとにモデルへのリクエストになり、システムプロンプト、ツール定義、履歴を読み直すので、短い「running」の結果でも数万トークンの入力になることがあります。MCPクライアントが確認する場合(Tasks拡張)は、プロトコルのメッセージなのでLLMのトークンは消費しません。

長時間かかるMCPツールをポーリングすると、いくらかかりますか?

私の試算(Claude Sonnet 5.5、コンテキスト30,286トークン)では、キャッシュありの確認1回が約0.0039ドル、キャッシュなしが約0.061ドルです。6分のジョブを60回続けて確認すると、1,000ジョブあたりキャッシュありで254.23ドル、なしで4,124.52ドルになります。

MCP Tasks拡張とは何ですか?

時間のかかるリクエストのための、中核のMCP仕様に対する拡張(io.modelcontextprotocol/tasks)です。サーバーは resultType: "task" と taskId、pollIntervalMs を返し、クライアントはタスクが completed・failed・cancelled になるまで tasks/get で確認します。拡張を宣言していないクライアントに、サーバーがタスクを返してはいけません。

Claude CodeはMCPタスクに対応していますか?

MCPのドキュメントによると、Claude Code v2.1.304以降でパブリックベータとして対応しています。Claude Codeが自分で tasks/get を送って確認し、タスクの実行中もClaudeは作業を続けます。古いバージョンや他のクライアントには、ロングポーリングの状態確認ツールなどの代わりの手段が必要です。

ツールの説明に書いた間隔より、エージェントが速く確認してしまうのはなぜですか?

モデルは途中で止まって待つことができないからです。ターンが終わるとすぐに次の呼び出しをするので、実際の確認の頻度はエージェントのループの速さで決まります。間隔を空けたいなら、ジョブが終わるか時間が過ぎるまで返らない wait_seconds のような引数で、サーバー側に待たせます。

MCPのロングポーリングとは何ですか?

状態確認のツールが、すぐに「running」を返さず、60秒などの上限までサーバー側で待ってから答える方式です。どのMCPクライアントでも使え、私の試算では6分のジョブの確認が60回から7回になりました。待ち時間は、プロキシやクライアントのタイムアウトより短くします。

プロンプトキャッシュを使えばポーリングは安くなりますか?

安くはなりますが、十分ではありません。私の試算ではSonnet 5.5で確認1回が約0.061ドルから0.0039ドルになりますが、60回ではTasksの66倍かかります。確認の間隔が5分を超えるとキャッシュが切れ、毎回コンテキスト全体にキャッシュ書き込みの料金がかかります。

1時間TTLのキャッシュはいつ使うべきですか?

同じエージェントが5分より長く、1時間より短い間隔で確認に戻ってくる場合です。長いジョブを定期的に確認するときが典型です。1時間の書き込みは入力の2倍の料金ですが、その後の確認はキャッシュから読めます。私の試算では、10分おき6回の確認が1,000ジョブあたり462.17ドルから142.08ドルになりました。

コード実行で長時間のジョブを待てますか?

サンドボックスの実行時間の上限がジョブより長ければ待てます。スクリプトでジョブを始め、終わるまで状態確認のツールを呼び、結果だけを返すので、モデルが払うのはリクエスト1回分です。1回の実行あたりのツール呼び出しの上限にかからないよう、スクリプトの中ではロングポーリングの状態確認ツールを使います。

ここでいう「MCP Token」は、MCPのアクセストークンのことですか?

違います。この記事はコンテキストと課金の単位であるLLMのトークンについての記事です。MCPサーバーのアクセストークンやAPIキーはセキュリティの話題です。

まとめ

長時間かかるMCPツールの完了をモデルが待つと、「終わった?」のたびにコンテキストを読み直すリクエストが発生し、MCPのトークン消費はジョブの長さに比例して増えます。私のSonnet 5.5の試算では、6分のジョブを60回続けて確認すると、1,000ジョブあたりキャッシュありで254.23ドル、なしで4,124.52ドルでした。5分のキャッシュの寿命を超える間隔の確認は、1回あたりさらに高くつきます。対策は、待つ役目をモデルから外すことです。クライアントが対応していればMCP Tasks(3.85ドル)、コード実行のスクリプト1本(4.73ドル)、サーバー側のロングポーリング(27.25ドル)が使えます。モデルが確認するしかない場合は、キャッシュを効かせ、間隔が長い確認には1時間TTLを使い、状態の結果を短くし、終わったら削除してください。

参考資料

NodeFlare

MCP専用ホスティングサービス

GitHubにあるMCPを簡単デプロイ・簡単運用で最適化
無料で始める

他の記事

MCPセキュリティ2026年11月22日

MCPクライアントの許可リスト:CIMDで接続元を制限する信頼ポリシーとSSRF対策、localhostなりすましの限界を検証(MCP Security、2026年)

MCPサーバーに接続できるクライアントを制限するMCP Securityガイド。2026-07-28版仕様の4つの登録方式、CIMDが証明すること・しないこと(localhostなりすまし)、SSRFを防ぐ取得ルール、4区分の信頼ポリシー、検証済みチェッカー(21/21、素朴な実装は4/10)、KeycloakとEntraの対応状況を解説。

MCPホスティング2026年11月22日

Docker MCP GatewayをリモートのMCP Hostingにする方法:streaming設定・Bearerトークン・docker.sock問題と静的モード【v0.44.3対応】

Docker MCP GatewayをリモートのMCP Hostingとして使い、Claude Code・Cursor・自作エージェントから接続する方法を解説。streamingの/mcp、未設定だと再起動ごとに変わるMCP_GATEWAY_AUTH_TOKEN、Compose+Caddyの構成、docker.sock不要の静的モード、セッション単位のメモリ試算、Originの403まで、ソースで確認しました。

MCPトークン2026年11月21日

サブエージェントでMCPのトークン消費は増える?エージェントごとのツール一覧の重複課金、並列起動のキャッシュミス、MCPツールの絞り方【Claude Code・Agent SDK、2026年版】

サブエージェントはそれぞれMCPのツール定義を読み込み、同時に起動するとキャッシュ書き込みも重なります。起動時に読み込むもの、Sonnet 5.5での試算(1,000回あたり348.58ドル→76.58ドル)、任せるべきかの損益分岐、tools・disallowedTools・mcpServersでサブエージェントごとにMCPツールを絞る方法を解説します。

MCPの「ポーリング税」:長時間ツールの状態確認がMCPトークン消費を増やす仕組みと、Tasks・ロングポーリング・コード実行による4つの安い待ち方【2026年版】 | Blog | Nodeflare