AI エージェントフレームワーク 2026 徹底比較 — LangChain・LangGraph・LlamaIndex・CrewAI・AutoGen・PydanticAI・Mastra・DSPy・MCP 完全ガイド

はじめに — 2026年5月、「エージェントフレームワーク」は統合と分化の終盤にある

2023年末から2024年初頭まで吹き荒れた熱狂が一段落した今、2026年5月時点で AI エージェントフレームワーク市場は 3 つの大きな潮流に整理されつつある。第一に、LangChain は止まらない批判(過度の抽象化、頻繁な破壊的変更、デバッグの難しさ)を受けながらもシェア 1 位を維持している。第二に、**Anthropic が提案した MCP(Model Context Protocol)**が事実上のツール標準になり、フレームワーク固有のロックインが弱まりつつある。第三に、PydanticAI や Mastra のように「型安全」を前面に出した新興フレームワークがエンタープライズにおいて LangChain の地位を侵食しつつある。

本稿はマーケティング比較表ではない。「今、本番環境で何がどこに入っているか」を正直に見ていく。LangGraph の StateGraph、LlamaIndex の query engine、CrewAI の Crew/Task/Agent、PydanticAI の Agent デコレーター、Mastra の TypeScript エージェント、DSPy のコンパイラ、Instructor の構造化出力、そして OpenAI Agents SDK と Vercel AI SDK 4 まで、実際の API コードと共に比較する。

エージェントフレームワーク 2026 — 6 つのレイヤーに分解する

まず全体像から。2026 年の標準エージェントスタックは次の 6 つのレイヤーに分かれる。

1. オーケストレーション(orchestration): エージェントループ、ツール呼び出し、状態管理
2. 構造化出力(structured output): Pydantic、Zod、JSON Schema、制約デコーディング
3. RAG / 知識(knowledge): 埋め込み、ベクトル検索、GraphRAG、コンテキスト圧縮
4. ツール標準(tool standard): MCP、OpenAPI function calling、A2A
5. メモリ(memory): 短期コンテキスト、長期エピソディック、ユーザー単位の状態
6. 観測性と評価(observability and eval): trace、run replay、eval suite

レイヤー 1 つを 1 ~ 2 個のツールが担えばよかった時代は終わった。今は レイヤー内部でも「LangChain 陣営」「Python ネイティブ陣営」「TypeScript 陣営」が分かれる。以下、レイヤーごとに見ていく。

LangChain — 批判を受けながらシェア 1 位である理由

2025 年を通して、X(旧 Twitter)と Hacker News では LangChain について「これを使うべきでない理由」というポストが毎週のように上がっていた。それでも、2026 年 5 月時点で PyPI ダウンロード統計では LangChain 系(langchain、langchain-core、langchain-community)が依然として月間 6,000 万ダウンロードを超える。理由は単純で、既に書かれたコードが多すぎるし、統合されている LLM・ベクトル DB・ツールの数が圧倒的だからである。

中核は **LangChain Expression Language(LCEL)**だ。パイプ演算子でチェーンを組み立て、Runnable インターフェイスで同期・非同期・ストリーミングを一気に処理する。v0.3 以降は安定化し、破壊的変更も減った。

from langchain_anthropic import ChatAnthropic
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

llm = ChatAnthropic(model="claude-opus-4-5-20250929")
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a senior staff engineer reviewing code."),
    ("human", "Review this diff and return concerns:\n\n{diff}"),
])

chain = prompt | llm | StrOutputParser()
result = chain.invoke({"diff": "<the code diff>"})

上記コード中の {diff} は LangChain のプロンプトテンプレート placeholder である。同じパターンで {question} {context} のような変数がチェーン全体に伝播する。LangChain の本当の価値はこの placeholder の統一と、with_structured_output、bind_tools、with_fallbacks といったメソッドの一貫性にある。

LangGraph — LangChain 自身が認めた「チェーンの限界」

LCEL は線形チェーンには良いが、エージェントの本質である「条件分岐、ループ、人間介入」には足りない。LangGraph はこの問題を解くために LangChain チーム自身が作った 状態グラフライブラリだ。2025 年後半、LangGraph は LangChain で最も急成長したパッケージとなった。

中核は StateGraph である。ノードは関数、エッジは条件、状態は reducer で蓄積される。ReAct パターン、マルチエージェントのハンドオフ、人間によるレビュー(human-in-the-loop)のチェックポイントが、すべてグラフの上に自然に乗る。

from typing import Annotated, TypedDict
from langgraph.graph import StateGraph, START, END
from langgraph.graph.message import add_messages

class AgentState(TypedDict):
    messages: Annotated[list, add_messages]
    next: str

def planner(state: AgentState) -> dict:
    return {"next": "researcher", "messages": [{"role": "assistant", "content": "plan"}]}

def researcher(state: AgentState) -> dict:
    return {"next": END, "messages": [{"role": "assistant", "content": "found"}]}

graph = StateGraph(AgentState)
graph.add_node("planner", planner)
graph.add_node("researcher", researcher)
graph.add_edge(START, "planner")
graph.add_conditional_edges("planner", lambda s: s["next"])
app = graph.compile(checkpointer=...)

LangGraph の決め手は checkpointer である。実行中の状態を SQLite/Postgres/Redis に保存し、人間の承認後に再開したり、任意の分岐点からのタイムトラベルデバッグを可能にしたりする。本番エージェント最大の問題(途中で止まって人間の確認を取る)が、このパターンで自然に解決する。

LlamaIndex — RAG の深さで差別化

LlamaIndex(2022 年に GPT Index として開始)は LangChain と同時期に出発したが、検索拡張生成(RAG)に集中することで別の道を歩んだ。2026 年現在の LlamaIndex は「エージェントもできるが本陣は RAG」である。70 種類以上のローダー、多層インデックス、GraphRAG、multi-query routing、MetaGPT 風の workflows までを 1 つのパッケージに収めている。

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.core.query_engine import RetrieverQueryEngine
from llama_index.core.retrievers import VectorIndexRetriever
from llama_index.llms.anthropic import Anthropic

documents = SimpleDirectoryReader("./docs").load_data()
index = VectorStoreIndex.from_documents(documents)

retriever = VectorIndexRetriever(index=index, similarity_top_k=10)
query_engine = RetrieverQueryEngine(
    retriever=retriever,
    llm=Anthropic(model="claude-opus-4-5-20250929"),
)

response = query_engine.query("What is the on-call rotation policy?")
print(response.response)
for node in response.source_nodes:
    print(node.metadata["file_path"], node.score)

2025 年後半から LlamaIndex は Workflow というイベント駆動の抽象を推している。LangGraph のグラフに似ているが、イベントディスパッチモデルを用いる。GraphRAG(エンティティグラフ + 埋め込み)の実装は、ここが最も滑らかという評価が多い。

CrewAI — ロールベースマルチエージェントの代表

CrewAI は 2024 年に João Moura が立ち上げたフレームワークで、**「エージェントは役割を持つ同僚のように協働すべき」**というモデルをコードに落とし込む。Agent、Task、Crew、Process という 4 つのファーストクラス概念だけで動く。LangChain より入口の敷居が低く、非開発者の PoC でよく使われる。

from crewai import Agent, Task, Crew, Process

researcher = Agent(
    role="Senior Researcher",
    goal="Find the latest on Claude Opus 4.5 benchmarks",
    backstory="A meticulous AI researcher who cross-checks every source.",
    verbose=True,
)

writer = Agent(
    role="Technical Writer",
    goal="Turn research into a 500-word brief",
    backstory="Writes for engineering leaders. No fluff.",
    verbose=True,
)

task1 = Task(description="Collect 5 sources", agent=researcher, expected_output="bullet list")
task2 = Task(description="Write the brief", agent=writer, expected_output="markdown")

crew = Crew(agents=[researcher, writer], tasks=[task1, task2], process=Process.sequential)
result = crew.kickoff()

CrewAI 1.0(2025 年 4 月)以降は Flow というグラフベース API が加わり、LangGraph に近い分岐パターンも書けるようになった。欠点はデバッグだ — エージェントの自由度が高く、ずれると遠くまで行く。評価・観測は LangSmith または独自の CrewAI Plus クラウドに依存する。

AutoGen — Microsoft の会話型マルチエージェント

AutoGen は Microsoft Research が 2023 年に公開したマルチエージェント会話フレームワークである。2025 年の 0.4 リリースで完全に再設計された。中核の抽象は **「エージェント間の会話」**で、GroupChat と GroupChatManager がラウンドを調整する。

from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_ext.models.openai import OpenAIChatCompletionClient

model_client = OpenAIChatCompletionClient(model="gpt-4o")

coder = AssistantAgent("coder", model_client=model_client,
    system_message="You write Python. Output a single function.")
reviewer = AssistantAgent("reviewer", model_client=model_client,
    system_message="You review code. Approve or reject with reasons.")

team = RoundRobinGroupChat([coder, reviewer], max_turns=4)
result = await team.run(task="Write a function that parses ISO 8601 dates.")

AutoGen Studio は視覚的にエージェントを構成し、実行結果を即座に確認する GUI である。学術界・研究 PoC でのシェアが高い。ただし、本番運用(スレッドの永続化、バックグラウンド実行、retry ポリシー)はまだ LangGraph より弱いという声が多い。

PydanticAI — 型安全エージェントの新興強者

PydanticAI は Pydantic チーム(Samuel Colvin ら)が 2024 年末に公開したエージェント SDK である。キャッチコピーは 「FastAPI-feel for AI agents」。Pydantic のデータ検証をエージェントのツールシグネチャと出力スキーマにそのまま適用する。エンタープライズにおいて LangChain の代替として最も速く採用が進んでいる。

from pydantic import BaseModel
from pydantic_ai import Agent, RunContext

class WeatherResult(BaseModel):
    city: str
    temp_c: float
    condition: str

agent = Agent(
    "anthropic:claude-opus-4-5-20250929",
    result_type=WeatherResult,
    system_prompt="Return current weather as structured data.",
)

@agent.tool
async def get_weather(ctx: RunContext, city: str) -> dict:
    return {"temp_c": 18.4, "condition": "cloudy"}

result = await agent.run("What's the weather in Seoul?")
print(result.data.city, result.data.temp_c)

PydanticAI の強みは 依存性注入と 型推論である。RunContext で DB/HTTP クライアントを注入し、@agent.tool デコレーターは関数シグネチャから JSON Schema を自動生成する。観測は Pydantic Logfire とファーストクラス統合されており、OpenTelemetry にも出力できる。

Mastra — TypeScript 陣営のエージェントフレームワーク

Mastra は 2024 年に Shane Thomas らが立ち上げた TypeScript-first エージェントフレームワークである。Vercel AI SDK の上に乗せて動作し、Cloudflare Workers/Vercel Edge/Node.js のすべてで走る。JavaScript フルスタック陣営(特に Next.js 採用企業)で急速にシェアを伸ばしている。

import { Mastra } from "@mastra/core";
import { Agent } from "@mastra/core/agent";
import { anthropic } from "@ai-sdk/anthropic";
import { z } from "zod";

const supportAgent = new Agent({
  name: "support",
  instructions: "You handle customer support tickets concisely.",
  model: anthropic("claude-opus-4-5-20250929"),
  tools: {
    lookupOrder: {
      description: "Look up an order by id",
      parameters: z.object({ orderId: z.string() }),
      execute: async ({ orderId }) => ({ orderId, status: "shipped" }),
    },
  },
});

const mastra = new Mastra({ agents: { support: supportAgent } });
const result = await mastra.getAgent("support").generate("Where is order 1234?");

Mastra はワークフロー(LangGraph 類似)、RAG、評価、メモリまでを 1 つのパッケージにまとめている。2026 年に入り Vercel との公式提携が深まる中、Next.js App Router の server actions と組み合わせるパターンが標準になりつつある。

agno · smolagents · Cog · Letta — 軽量・特化陣営

• agno(旧 Phidata): 「fast agent framework」を標榜する。LangChain 比 5 倍軽量なランタイムオーバーヘッドを謳う。マルチモーダル、メモリ、チームエージェントがファーストクラス概念。
• smolagents: HuggingFace が 2024 年末に公開したミニマルフレームワーク。「エージェントとはコード実行ツールを持つ LLM」という定義 1 つから出発する。CodeAgent は Python コードを直接生成して実行する。
• Cog(Replicate): エージェントフレームワークではないが、エージェントをコンテナにパッケージングする際の事実上の標準。cog.yaml 1 ファイルで GPU モデル・エージェントを OCI イメージにする。
• Letta(旧 MemGPT): UC Berkeley から始まったメモリ中心エージェント。中核パラダイムは「OS のようにコンテキストをページイン・ページアウトする」。長時間対話ボットでのシェアが最も高い。

DSPy — Stanford が作った「プロンプトプログラミング」パラダイム

DSPy は Omar Khattab(Stanford)が主導するライブラリで、プロンプトを直接書かずシグネチャとモジュールで宣言した後、コンパイラが自動最適化するモデルを提案する。2026 年現在、学術界と一部のヘッジファンド・研究所で積極的に採用されている。

import dspy

lm = dspy.LM("anthropic/claude-opus-4-5-20250929")
dspy.configure(lm=lm)

class RAG(dspy.Module):
    def __init__(self):
        super().__init__()
        self.retrieve = dspy.Retrieve(k=5)
        self.generate = dspy.ChainOfThought("context, question -> answer")

    def forward(self, question):
        ctx = self.retrieve(question).passages
        return self.generate(context=ctx, question=question)

rag = RAG()
optimized = dspy.MIPROv2(metric=dspy.evaluate.answer_exact_match).compile(rag, trainset=train)

中核の洞察は「プロンプトエンジニアリングはコード生成に置き換わる」というものだ。few-shot 例の選定、指示文の作成、chain-of-thought の形式までも、コンパイラ(MIPROv2、BootstrapFinetune など)が学習データで自動チューニングする。

Instructor と Outlines — 構造化出力の二大巨頭

LLM が毎回きれいな JSON を吐かない、という問題は 2023 年から知られていた。2026 年現在、解法は 2 つに標準化された。

• Instructor(jxnl/instructor): Pydantic モデルを関数シグネチャとして渡せば、LLM がその形で返す。retry と validation がファーストクラス。OpenAI/Anthropic/Mistral/Gemini を同じ API で扱える。
• Outlines: 正規表現/JSON Schema/文法(grammar)で トークン単位の制約デコーディングを行う。ローカルモデル(vLLM、Transformers)で 100% スキーマ準拠を保証する。

import instructor
from anthropic import Anthropic
from pydantic import BaseModel

class Ticket(BaseModel):
    title: str
    severity: str
    components: list[str]

client = instructor.from_anthropic(Anthropic())
ticket = client.messages.create(
    model="claude-opus-4-5-20250929",
    response_model=Ticket,
    max_tokens=1024,
    messages=[{"role": "user", "content": "Login broken on iOS Safari only, P0."}],
)
print(ticket.severity, ticket.components)

Instructor はクラウド API 中心、Outlines はローカル推論中心で、領域がはっきり分かれる。両ライブラリとも Marvin や Guardrails AI より依存が軽くデバッグも容易、という評が多い。

OpenAI Agents SDK · Vercel AI SDK 4 · Anthropic SDK — ベンダー SDK の進化

ベンダー SDK ももはや「単純な LLM 呼び出しライブラリ」ではない。

• OpenAI Agents SDK(2024 年末に正式リリース): Agent、Runner、handoffs、guardrails がファーストクラス概念。Swarm(2024 年実験版)の正式後継。
• Vercel AI SDK 4: streamText、generateObject、tool ヘルパーで、React Server Component のストリーミングとツール呼び出しを数行で処理。
• Anthropic Python/TS SDK: messages.create の tools と tool_choice パラメータでツール呼び出し、加えて computer_use ツールタイプをサポート。

import { streamText, tool } from "ai";
import { anthropic } from "@ai-sdk/anthropic";
import { z } from "zod";

const result = streamText({
  model: anthropic("claude-opus-4-5-20250929"),
  prompt: "Summarize today's PR list.",
  tools: {
    listPRs: tool({
      description: "List open PRs",
      parameters: z.object({ repo: z.string() }),
      execute: async ({ repo }) => ({ prs: [] }),
    }),
  },
  maxSteps: 5,
});

for await (const chunk of result.textStream) process.stdout.write(chunk);

Bedrock Agents(AWS)、Google Gemini Function Calling、Cloudflare AI Agents まで加えると、2026 年は主要クラウドベンダーすべてがエージェント SDK をファーストクラスで提供する時代である。

MCP — Anthropic が作ったツール標準、2026 年に事実上の de-facto

Model Context Protocol(MCP)は Anthropic が 2024 年末に公開した JSON-RPC ベースのツール/リソースプロトコルである。1 年半で、LangChain、LlamaIndex、OpenAI Agents、Vercel AI SDK、Mastra のすべてが MCP クライアントをファーストクラスでサポートするようになった。2026 年 5 月時点で公式レジストリに登録された MCP サーバーは 800 を超える。

from mcp.server import Server
from mcp.server.stdio import stdio_server

app = Server("calendar-server")

@app.list_tools()
async def list_tools():
    return [{
        "name": "create_event",
        "description": "Create a calendar event",
        "inputSchema": {"type": "object", "properties": {"title": {"type": "string"}}},
    }]

@app.call_tool()
async def call_tool(name, arguments):
    if name == "create_event":
        return [{"type": "text", "text": f"created: {arguments['title']}"}]

async with stdio_server() as (r, w):
    await app.run(r, w, app.create_initialization_options())

MCP の中核的な洞察は **「ツールはサーバー、エージェントはクライアント」**という分離である。Slack、GitHub、Notion、Postgres、Stripe といった企業が公式 MCP サーバーを提供すれば、どのエージェントフレームワークも同じツール群にアクセスする。ロックインが崩れる。

A2A — Google が提案する Agent-to-Agent プロトコル

A2A(Agent2Agent)は 2025 年初頭に Google が公開したエージェント間協調の標準である。MCP が「エージェントとツールの間」だとすると、A2A は「エージェントとエージェントの間」のメッセージ形式、能力公示(capability advertisement)、タスクのハンドオフを標準化する。

現状の採用は MCP より遅いが、Salesforce、ServiceNow、Atlassian のような SaaS ベンダーがマルチエージェントメッシュ構築のため A2A に賭けている。2026 年 5 月時点で LangChain と Vertex AI Agents が A2A アダプターを提供している。

{
  "name": "research-agent",
  "version": "1.0.0",
  "capabilities": [
    { "name": "web.search", "description": "Search the web" },
    { "name": "doc.summarize", "description": "Summarize a document" }
  ],
  "endpoints": { "rpc": "https://agent.example.com/a2a" }
}

上記は A2A の能力カード(capability card)の例である。他のエージェントはこのカードを見て、どのタスクを委譲するかを決める。

ツール呼び出し標準 — OpenAI function calling、Anthropic tool use、JSON Schema

ベンダー別のツール呼び出し形式は依然として微妙に異なる。2026 年時点の主要な標準は次の通り。

• OpenAI Chat Completions function calling: tools 配列に JSON Schema を登録し、tool_calls で受け取る。
• Anthropic tool use: tools 配列 + tool_use コンテンツブロック。input_schema は JSON Schema 互換。
• Google Gemini Function Calling: FunctionDeclaration オブジェクトで登録。スキーマは OpenAPI 3.0 のサブセット。
• MCP: inputSchema は JSON Schema。上記すべてと互換に変換できる。

LangChain、LlamaIndex、PydanticAI、Mastra のようなフレームワークはこの差をアダプターで吸収する。SDK を直接使うときだけ違いを意識すれば十分である。

guidance · BAML · griptape · Agency Swarm — 特化領域の強者

• guidance(Microsoft): トークン単位の制約デコーディングをコードのように表現する。JSON Schema より精密な制御が可能だが学習曲線がある。
• BAML(Boundary ML): プロンプトと関数を 別途 .baml ファイルに宣言し、TypeScript/Python コードを自動生成する。「プロンプトをコードのように」バージョン管理するパターン。
• griptape: エンタープライズ RAG・エージェント。Drivers、Memory、Rulesets のような抽象が明確で、セキュリティ・ガバナンスのメタデータがファーストクラス。
• Agency Swarm(VRSEN): OpenAI Assistants API の上にマルチエージェント通信を載せる。社内自動化を素早く PoC するのに良い。

エージェント評価 — LangSmith、Phoenix、Langfuse、Galileo、Patronus、DeepEval

エージェントにとっては「実行 trace」がそのままデバッグ単位となる。2026 年市場は 5 グループに分かれる。

1. LangSmith(LangChain Inc.): LangChain 陣営の標準。trace、dataset、evaluator、online eval すべてファーストクラス。
2. Arize AI Phoenix: オープンソース、OpenTelemetry ベース。セルフホストが容易で、OpenInference 仕様によってあらゆるフレームワークをサポート。
3. Langfuse: オープンソース + クラウド。セルフホストが簡単で、価格も LangSmith より親しみやすいため、スタートアップに好まれる。
4. Galileo、Patronus AI、Confident AI DeepEval: 評価(metric、hallucination 検知、regression)中心。CI/CD への組み込みに向く。
5. Weights & Biases Weave: 既存 W&B ユーザーに馴染みやすい trace ビュー。

import phoenix as px
from openinference.instrumentation.langchain import LangChainInstrumentor

px.launch_app()
LangChainInstrumentor().instrument()

result = chain.invoke({"diff": "..."})

Phoenix の強みは OpenTelemetry GenAI semconv 1.0 との整合性である。2025 年後半に OTel SIG が GenAI セマンティック規約を安定化させたことで、trace の互換性が大きく向上した。

エージェントメモリ — Mem0、Zep、Pinecone、Qdrant、Redis

長期メモリは 2026 年で最も早く成熟したレイヤーである。4 パターンが標準化された。

• Mem0: 「ユーザー別メモリレイヤー」をファーストクラス API で。fact extraction と retrieval を自動化。
• Zep: セッションメモリ + ナレッジグラフ。会話履歴を自動でエンティティグラフにインデックス化。
• Pinecone/Qdrant/Weaviate/Milvus: エピソディックメモリ用のベクトルストア。
• Redis + Postgres pgvector: 短期キャッシュ + 永続状態。

LangGraph は独自の Memory 抽象で上記すべてをアダプターとしてラップする。PydanticAI も 2025 年後半に Memory のファーストクラスサポートを追加した。

ガードレール — Guardrails AI、NeMo Guardrails、Lakera Guard

本番エージェントは jailbreak、PII 漏洩、ポリシー違反を防がねばならない。3 ライブラリが標準である。

• Guardrails AI: RAIL 仕様で入出力を検証。Python/JS の両方をサポート。
• NVIDIA NeMo Guardrails: Colang DSL で会話フローのルールを宣言。ツール呼び出しの制限も可能。
• Lakera Guard: 商用 API。prompt injection の検知精度が最も高いとの評が多い。

rails:
  input:
    flows:
      - self check input
  output:
    flows:
      - self check output
      - check policy

上記は NeMo Guardrails の config.yml の一部だ。入出力ごとにフローを設定してポリシーを検証する。

フレームワーク比較表 — ひと目で整理

選択ガイド — 2026 年 5 月、何を選ぶか

大原則は単純である。

1. 既に LangChain コードが多い: LangGraph に段階的に移行する。新規コードは LangGraph、既存 LCEL はそのまま。
2. 型安全とエンタープライズガバナンスが重要: PydanticAI。Pydantic のエコシステムをそのまま受け継げる。
3. TypeScript フルスタック(Next.js、Cloudflare Workers): Mastra か Vercel AI SDK 4。RSC との組み合わせが自然。
4. RAG が本陣で GraphRAG まで必要: LlamaIndex。
5. 複数役割の協調を素早く PoC: CrewAI。
6. 研究室・論文再現・ベンチマーク自動チューニング: DSPy。
7. ローカルモデル(vLLM) + 100% スキーマ準拠: Outlines。
8. 単一ベンダー(OpenAI/Anthropic)へのロックインで問題ない: OpenAI Agents SDK か Anthropic SDK を直接利用。

ツールは無条件で MCP サーバーとして公開することを推奨する。将来のフレームワーク差し替えが自由になる。

コスト管理 — トークン会計とキャッシング

本番エージェントでは LLM トークンがそのままコストになる。2026 年の標準は 3 つだ。

• prompt caching: Anthropic の cache_control、OpenAI の prompt caching、Gemini の context caching すべてが 5 分 TTL ベース。システムプロンプトとツール定義をキャッシュブロックに出すと 75% 以上のコスト削減。
• batch API: 時間に敏感でないワークロードは OpenAI/Anthropic の batch API で 50% 割引。
• モデルカスケード: まず Haiku/Mini で処理し、失敗したものだけ Opus/4 へ。LangChain with_fallbacks、PydanticAI の models リストで実装。

LangSmith、Helicone、OpenLLMetry はいずれもトークンコストを trace 単位で集計する。社内ダッシュボードを作る前に、まずこの 3 つのうちのどれかを入れるのが効率的だ。

アンチパターン — これをやると半年後に後悔する

1. LangChain を「全部」使う: langchain-community のすべての統合を持ち込むと、依存爆発とセキュリティ監査地獄に陥る。必要な統合だけを直接 import する。
2. エージェントに無限ループを許す: max_iterations と max_steps を必ず設定する。コスト暴走の原因第 1 位。
3. メモリのないマルチターンエージェント: Mem0/Zep なしに毎ターン全履歴を LLM に押し込むと、トークンコストが線形ではなく二乗で増える。
4. eval なしで本番投入: LangSmith/Phoenix dataset に最低 50 件のゴールデンケースを用意し、回帰テストとして回す。
5. MCP なしのツールロックイン: ツールを LangChain @tool デコレーターだけで公開すると、他フレームワークへ移すときに全部書き直しになる。MCP サーバーに切り出せば自由だ。
6. リリース直前のガードレール後付け: jailbreak シナリオと PII 漏洩は最初からテストケースに入れる。

おわりに — 2026 年後半の展望

2026 年後半に我々が目にするのは次の 3 つだろう。

• MCP の完全標準化: ISO/IETF レベルの形式標準の議論が始まる。クラウドベンダー間のツール互換性が保証される。
• 型安全エージェントのエンタープライズ標準化: PydanticAI と Mastra が LangChain のシェアを急速に侵食する。特に金融・医療・公共。
• エージェント OS の登場: Letta(MemGPT)流の「エージェントオペレーティングシステム」抽象が LangGraph と合流し、バックグラウンド・長時間実行・人間レビューがファーストクラス機能になる。

これから始めるチームには、LangGraph + PydanticAI + MCP + LangSmith(または Phoenix)を既定の組み合わせとして勧める。TypeScript が本陣なら Mastra + Vercel AI SDK + OTel だ。1 年後に振り返っても後悔の少ない組み合わせである。

References

• LangChain 公式ドキュメント: docs.langchain.com
• LangGraph 公式ドキュメント: langchain-ai.github.io/langgraph
• LlamaIndex 公式ドキュメント: docs.llamaindex.ai
• CrewAI 公式ドキュメント: docs.crewai.com
• AutoGen 公式サイト: microsoft.github.io/autogen
• PydanticAI 公式サイト: ai.pydantic.dev
• Mastra 公式サイト: mastra.ai
• agno 公式ドキュメント: docs.agno.com
• smolagents 公式ドキュメント: huggingface.co/docs/smolagents
• DSPy 公式サイト: dspy.ai
• Instructor: github.com/jxnl/instructor
• Outlines: github.com/outlines-dev/outlines
• Model Context Protocol: modelcontextprotocol.io
• OpenAI Agents SDK: openai.github.io/openai-agents-python
• Anthropic 公式ドキュメント: docs.anthropic.com
• Vercel AI SDK: sdk.vercel.ai
• LangSmith: smith.langchain.com
• Arize Phoenix: phoenix.arize.com
• Langfuse: langfuse.com
• Galileo: galileo.ai
• Patronus AI: patronus.ai
• Confident AI DeepEval: confident-ai.com
• Weights & Biases Weave: wandb.ai/site/weave
• Mem0: mem0.ai
• Zep: getzep.com
• Guardrails AI: guardrailsai.com
• NeMo Guardrails: github.com/NVIDIA/NeMo-Guardrails
• Lakera Guard: lakera.ai
• OpenTelemetry GenAI semconv: opentelemetry.io/docs/specs/semconv/gen-ai
• A2A protocol: google.github.io/A2A