New in Deep Agents v0.6
LangChain Blog が発表した Deep Agents v0.6 は、オープンウェイトモデルの活用コスト削減、長期間実行時のストレージ効率化、およびリアルタイム UI 構築機能の強化により、実運用レベルのエージェント開発を劇的に改善した。
キーポイント
オープンウェイトモデルによるコスト削減
Harness Profiles を活用することで、Kimi や Qwen、DeepSeek などのオープンウェイトモデルで生産環境並みのパフォーマンスを実現し、クローズドな最先端 API に比べて 20 倍以上のコスト削減を可能にした。
スケーラブルなインフラストラクチャの最適化
Delta Channels の導入により、長期実行エージェントにおけるチェックポイントストレージを最大 100 倍削減し、観測性や回復力を損なわずに大規模展開を実現した。
リアルタイム UI 構築の新機能
ストリーミングプリミティブにより、メッセージ、ツール呼び出し、サブエージェントなどのイベントを型安全かつ購読可能な形でフロントエンドへ直接投影し、リッチなリアルタイム UI の開発が容易になった。
コードインタープリタとコンテキスト管理の強化
サンドボックスのオーバーヘッドなしにツールを構成・状態管理できる軽量ランタイム（Code Interpreter）や、LangSmith Context Hub 連携によるバージョン管理されたスキル・ポリシー管理が追加された。
影響分析・編集コメントを表示
影響分析
このリリースは、LLM エージェントの実用化における最大の障壁である「コスト」と「スケーラビリティ」を同時に解決する重要な転換点です。特にオープンウェイトモデルの高品質な運用を可能にしたことは、企業が大規模かつ低コストで独自エージェントを構築する道を開き、AI アプリケーションの普及速度を加速させる可能性があります。
編集コメント
エージェント開発の現場では、コストとパフォーマンスのトレードオフに常に悩まされますが、このアップデートはオープンソースモデルでもクローズド API に匹敵する運用を可能にする画期的な進歩です。特にストレージ効率化とリアルタイム UI 機能は、大規模かつ複雑なエージェントシステムの構築において即座に役立つ実用的な改善と言えます。
主要なポイント
- オープンウェイトモデルで能力の高いエージェントを実行 — Harness プロファイルを使用すれば、Kimi、Qwen、DeepSeek などのモデルから、クローズドな最前線 API と比較して 20 倍以上の低コストで本番環境レベルのパフォーマンスを実現できます。
- スケールしたエージェントインフラのコスト削減 — Delta チャンネル（Delta channels）により、観測性や回復力を損なうことなく、長時間稼働するエージェントのチェックポイントストレージを最大 100 倍削減できます。
- より豊かでリアルタイムのエージェント UI を構築 — 新しいストリーミングプリミティブにより、ランタイムからフロントエンドまで一貫して、メッセージ、ツール呼び出し、サブエージェントに対する型安全で購読可能なイベント投影（event projections）を提供します。
最新の DeepAgents リリースは、モデル層におけるパフォーマンス、スケールしたエージェント層、そして時間経過に伴う安定性に焦点を当てています。今回のリリースには以下の 4 つの要素が貢献しています：
- コードインタプリタ：フルサンドボックスのオーバーヘッドなしに、ツールを構成し、状態を管理し、モデルコンテキストに到達する内容を制御するための軽量ランタイム。
- ハーネスプロファイル：実行中のどのモデル（Kimi、Qwen、DeepSeek などのオープンウェイトモデルを含む）でもハーネスが最大限の効果を得られるよう、モデルごとにチューニングを行う機能。
- ストリーミング：メッセージ、ツール呼び出し、サブエージェント、カスタムアプリケーションイベントに対する型付き投影。生のストリーム出力を解析するのではなく、アプリケーションが必要とするものだけを購読可能。
- DeltaChannel：エージェントの実行時間が長くなりコンテキストが蓄積しても、エージェントの再開可能性・観測性・回復力を支える堅牢な実行保証を損なうことなく、効率的にチェックポイントを保存。
- ContextHubBackend：LangSmith Context Hub をバックエンドとして活用し、エージェントの振る舞いを形作るスキル、ポリシー、メモリをバージョン管理され協働可能な場所で保存。これにより、ある実行で学習した内容が次の実行を改善できる。
コードインタプリタ
Deep Agents にインストール可能なコードインタプリタをリリースしました。これにより、エージェントはデータを変換し、ツール呼び出しを調整し、中間作業をモデルコンテキストから外に保持できるプログラム可能なワークスペースを得ます。エージェントが意図を表現するためにコードを書き、メモリ内のランタイムがそのコードを実行して関連する結果を返します。
サンドボックスが環境に対して行動するためのコードファーストの手法（コマンドの実行、依存関係のインストール、ファイルの編集など）である一方、インタプリタはエージェントループ内で行動するためのコードファーストの手法であり、ツールの構成、状態の保持、そしてモデルに返すべき情報の決定を行います。
1// エージェントは以下のようなコードを記述できます:
2const topics = ["retrieval", "memory", "evaluation"];
3
4const reports = await Promise.all(
5 topics.map((topic) =>
6 tools.task({
7 description:
8 Deep Agents における ${topic} を調査し、3 つの簡潔な知見を返してください。,
9 subagent_type: "general-purpose",
10 }),
11 ),
12);
13
14reports.join("\n\n");
これにより、特に私たちが興奮しているエージェントの新しい機能が可能になります:
モデル非依存の PTC (Programmatic Tool Calling)
標準的なツール呼び出しループでは、モデルが各ステップの交通整理役となります。モデルはツールの使用を要求し、文脈内で完全な結果を受け取り、その結果について推論を行い、これを繰り返します。中間の結果が次の入力を計算するためにのみ必要な場合でも、複数のモデル呼び出しを連鎖させる必要があります。
プログラムによるツール呼び出し (PTC: Programmatic Tool Calling) はこのワークフローを変えます。モデルは実行ランタイム内でツールを呼び出すコードを記述するため、個々のツール呼び出しごとにモデルへの往復通信を行わずにワークフローを実行できます。中間結果はランタイムの状態内に保持され、インタプリタがノイズの多い出力をフィルタリングしたり、データを処理したり、失敗した処理を再試行したりして、関連するコンテキストのみをモデルに戻すことができます。
1const pages = await Promise.all(
2 urls.map((url) => tools.fetchUrl({ url })),
3);
4
5const relevant = pages
6 .filter((page) => page.includes("interpreter"))
7 .slice(0, 3);
8
9relevant.map((page) => page.slice(0, 500));
このツール呼び出しのパターンは、トークン消費を削減し、避けられるモデルの往復回数を減らし、エージェントの推論ステップを小さくします。
Anthropic は、このパターンを自社のモデルファミリーに対する API 動作として追加することで普及に貢献しましたが、インタプリタ（interpreter）を使用すれば、オープンソースモデルを含むあらゆるモデルを持つエージェントで同様のことが実現可能になりました。
再帰的ワークフロー
インタプリタにより、エージェントはハネス（harness）とより革新的な方法で対話できるようになります。ツールやサブエージェントがコードから呼び出せるため、エージェントは一つのサブエージェントからの出力を取得し、それを検査・変換して、中間成果物をすべてメインモデルを経由して戻すことなく、次のステップに渡すことができます。
これにより再帰的ワークフローが可能になります：エージェントは質問のキューを保持し、次の質問に対してサブエージェントを呼び出し、結果を保存し、その結果からフォローアップ作業を生成し、十分な証拠が揃って回答を合成するまでこれを続けます。（これは単に「完全な入力コンテキストに対して別の LLM を呼び出す」ことよりも深い意味を持ちます。鍵となるのは、モデルのコンテキスト外で作業状態を維持し、各次の呼び出しに何を通すかを制御することです。）
1const frontier = ["What changed in interpreter middleware?"];
2const findings = [];
3
4while (frontier.length && findings.length < 6) {
5 const question = frontier.shift();
6
7 const report = await tools.task({
8 description:
9 Answer this question. If there is a useful next question,
10 include it as "Follow-up: ..."\n\n${question},
11 subagent_type: "general-purpose",
12 });
13
14 findings.push(report);
15
16 const next = report.match(/Follow-up: (.*)/)?.[1];
17 if (next) frontier.push(next);
18}
19
20findings.join("\n\n");
21
これは、再帰型言語モデル（Recursive Language Models: RLM）の背後にあるアイデアに隣接するものです：モデルのコンテキストの外で作業状態を維持し、選択されたブランチに対してモデルやサブエージェントを呼び出し、次のモデル呼び出しに入ってくるものを制御します。
Deep Agents においては、インタプリタがそのパターンのための動作ランタイムとなります。これは、モデル層で当初定義された意味で「RLM を行う」と主張するものではなく、あくまでそのパターンを実現するための手段です。
これらはすべて、pypi で deepagents[quickjs] をインストールするか、npm で @langchain/quickjs をインストールし、それをミドルウェアとして追加することで有効化できます。
1from deepagents import create_deep_agent
2from langchain_quickjs import REPLMiddleware
3
4agent = create_deep_agent(
5 model="baseten:zai-org/GLM-5",
6 middleware=[REPLMiddleware()],
7)
インタプリタに関する詳細情報は、ドキュメントをご覧ください。
Harness profiles
Kimi K2.6、GLM 5.1、DeepSeek V4 といったオープンウェイトモデルは、現在では生産環境におけるエージェントワークに実用可能となっており、クローズドな最前線モデルと比較してコストが 20 倍以上低い場合も珍しくありません。しかし、各モデルは異なるツール呼び出し形式やプロンプトの慣習に基づいてポストトレーニングされており、ほとんどのハルネス（harness）は著者が構築したクローズドモデル向けに調整されています。これをそのまま適用すると、モデルがハルネスが理解できない方言で話しているため、真の能力の一部しか発揮されない可能性があります。
このギャップは大きく、測定可能です。当社のテストでは、ハルネス層の変更だけで、Terminal-Bench 2.0（上位 30 → 上位 5）において gpt-5.2-codex のスコアを 52.8% から 66.5% に引き上げ、tau2-bench では gpt-5.3-codex を 20%、opus-4.7 を 10% 向上させました。tau2-bench 全体を通じて、モデルを変更しなくてもプロンプトやミドルウェア（middleware）によってスコアが 10 から 20 ポイント変動することがあります。
「ハルネス」とはモデルを取り巻くものであり、ベースとなるシステムプロンプト、ツールとその説明、各ターンを形成するミドルウェアを含みます。ハルネスプロファイルは、これらのモデル固有のオーバーライドを名前付きでバージョン管理可能な単位として捉えます。
DeepAgents v0.6 では、ハルネスプロファイルをファーストクラスの抽象化として扱います。プロファイルはモデルと共に差分比較・バージョン管理・差し替えが可能となり、チューニング作業の成果を引き継ぐことができます。主要なモデルに対してビルトインのプロファイルを提供しており、強力なパフォーマンスがデフォルトとなりますが、同じ仕組みは独自のスタックでも利用可能です。
異なるモデルにわたるディープエージェントのチューニングについては、こちらをご覧ください。tuning deep agents across different models。独自の設定を作成するには、ドキュメントをご参照ください。
ストリーミング
エージェントは最終回答を返すまでに多くの処理を行います。良好なユーザー体験を提供するためには、これらの処理が進行中に表示し、ユーザーがその過程でエージェントの方向性を制御できるようにする必要があります。ストリーミングはこの実現を可能にする基本機能です。LangChain の新リリースでは、ストリーミングが第一級アプリケーションプリミティブとして扱われます。stream_events(..., version="v3") を使用することで、エージェントとグラフは、開発者が実際にレンダリングしたいプリミティブ（メッセージテキスト、推論ブロック、ツール呼び出し、状態更新、サブグラフ、サブエージェント、カスタムチャンネル、最終出力）に対する使い勝手の良い投影を持つ統一されたイベントストリームを生成します。このストリームはコンテンツブロック中心に設計されており、UI はチャンクがテキスト、推論、メディア、またはツール呼び出しデータであるかを推測する必要がなくなります。すべての情報は型付きイベント、名前空間、チャンネルを中心に整理され、新しい Agent Streaming Protocol と完全に整合しています。
1stream = agent.stream_events(
2 {"messages": [{"role": "user", "content": "Research LangChain streaming"}]},
3 version="v3",
4)
5
6for message in stream.messages:
7 for delta in message.text:
8 print(delta, end="", flush=True)
9
10for subagent in stream.subagents:
11 print(f"\n[{subagent.name}] {subagent.status}")
12
13 for message in subagent.messages:
14 print(f"[{subagent.name}] ", end="")
15 for delta in message.text:
16 print(delta, end="", flush=True)
17 print()
このストリーミングモデルは、新しい Agent Server エンドポイントと SDK サポートを通じて、ネットワークを介しても引き継がれます。LangGraph SDK は、クライアントの threads.stream(...) を通じてリモートイベントストリーミングを公開しており、マルチモーダルコンテンツへの対応、再接続/再生機能、SSE または WebSockets によるトランスポート非依存な配信をサポートしています。ローカルとリモートのストリームが現在同じプロトコルに従うため、開発者はスクリプト、バックエンドサービス、本番環境のフロントエンドを問わず、エージェントの実行を一貫した方法で監視できるようになります。アプリケーションは、特定のサブエージェントからのメッセージやカスタムチャンネルからの更新、特定のネームスペース内のイベントなど、実行に必要な部分のみを購読することができます。
フロントエンドでは、本リリースにより @langchain/react、@langchain/vue、@langchain/svelte、@langchain/angular に対して v1 フレームワーク統合が導入され、イベントパーサーを手動で実装することなく、リッチなストリーミング体験を構築するための言語に即したフックとユーティリティを提供します。新しいスタックの探索を容易にするため、Streaming Cookbook も公開しています。これはメッセージストリーミング、サブグラフ、サブエージェント、カスタムストリームトランスフォーマー、マルチモーダル UI、再接続動作、およびフレームワーク固有のパターンをカバーする実行可能な例のコレクションです。その結果、精密さが必要な箇所では低レベルで、生産性を重視する箇所では高レベルであり、エージェントランタイムからユーザーインターフェースまで一貫性のあるストリーミング基盤が実現されます。
Delta channels
Deep Agents は LangGraph ランタイムを基盤としており、各ステップでエージェントの進捗をチェックポイントします。これにより、観測可能性、人間をループに組み込んだ処理、および障害回復が可能になります。常にエージェントがどこにいるかを正確に把握でき、任意の地点から再開できるのです。
エージェントの能力が高まるにつれて:
- メッセージ履歴が数十ステップ、あるいは数百ステップにわたって成長し、より長時間実行されるようになります
- より多くのコンテキストを利用するようになり、ファイルシステムをコンテキスト管理とオフロードのために活用します
DeepAgents においては、メッセージ履歴とファイルはエージェントの状態内に存在し、すべてのステップでスナップショットを取得するアプローチにより、チェックポイントの保存量は O(N²) で増加します。
デルタチャンネルは、ランタイムを進化させて追従するための仕組みです。すべてのチェックポイントで完全なスナップショットをシリアライズするのではなく、差分のみを保存します。Deep Agents においては、これはメッセージ履歴とファイルに対する差分ベースのストレージを意味します。
エージェントの進捗に関する完全な履歴は依然として取得できますが、ストレージコストは大幅に削減されます。また、これは長時間実行されるエージェントにおけるチェックポインタ（データベース）への書き込みのボトルネックを緩和し、スケール時のストレージコストもはるかに管理可能になります。
会話の長さやコンテキストサイズに応じて、デルタチャンネルへ切り替えることで、チェックポインタのストレージ量を 10〜100 倍削減できる可能性があります。
例えば、ある実験を考えてみてください。エージェントがファイルを作成し、ドキュメントを検索し、作業について推論を行うシミュレーションされたマルチファイルコーディングセッションです。これは、能力のあるコーディングエージェントが実際に実行する、持続的でコンテキスト負荷の高い作業の 200 ターンに相当します。デルタチャンネルを使用しない場合、そのセッションではチェックポイントストレージとして5.27 GBが蓄積されます。一方、デルタチャンネルを使用した場合：129 MBです。
同じエージェントにおける、デルタチャンネルの有無によるチェックポインタストレージの比較は以下の通りです：
そして、その爆発的な増加を視覚的に表したグラフは以下の通りです：
深いコンテキストを持つ長期実行型エージェントが業界の方向性であり、デルタチャンネル（delta channels）は、そのニーズに応えるためにランタイムをスケーリングさせる手段です。
詳細については、完全な記事をご覧ください。
ContextHub Backend
Context Hub は、LangSmith に基づく Deep Agents 用のファイルシステムです。エージェントの動作を形作るファイルに対してバージョン管理された場所を提供するため、プロンプト、スキル、その他のコンテキストへの改善点を、実行間を跨いで継続して反映させることができます。
内部では、エージェントは Hub リポジトリから読み込み（必要に応じて書き込みも）を行います。これらの書き込み履歴、レビュー機能、環境タグ付け付きのコミットとして保存されるため、別々のストレージ層を設定することなく、ステージング環境で反復開発を行い、本番環境へプロモートすることが可能になります。
エージェントのファイルシステムバックエンドとして使用するには：
from deepagents import create_deep_agent
from deepagents.backends import ContextHubBackend
agent = create_deep_agent(
model="google_genai:gemini-3.1-pro-preview",
backend=ContextHubBackend("my-agent"),
)または、ファイルシステムの残りをスレッドスコープに保ちつつ、/memories/ だけを Hub にスコープすることも可能です：
1from deepagents.backends import CompositeBackend, StateBackend, ContextHubBackend
2
3agent = create_deep_agent(
4 model="google_genai:gemini-3.1-pro-preview",
5 backend=CompositeBackend(
6 default=StateBackend(),
7 routes={
8 "/memories/": ContextHubBackend("my-agent"),
9 },
10 ),
11)
読み取りはキャッシュから提供され、書き込みは Hub リポジトリにコミットされます。リポジトリがまだ存在しない場合、最初の書き込みでそれが作成され、その後、他のバージョン管理されたコンテキストと同様に差分の表示、レビュー、変更へのタグ付けが可能になります。
ContextHubBackend を使用する前に LANGSMITH_API_KEY を設定してください。競合処理と制限については 完全なドキュメント を参照してください。
まとめ
Deep Agents の 5 月リリース全体に貫かれているのは、パフォーマンスです：
- Harness プロファイルを使用すると、最適なハネスを備えたモデルから性能を引き出し、フロンティア API の数分の一の費用でオープンウェイトモデル上で実行可能なエージェントランを実現できます。
- コードインタプリタにより、エージェントはコードの記述と実行に対してより高い自律性を獲得し、複雑なタスクの達成やコンテキストウィンドウの使用効率の最適化が可能になります。
- ストリーミング機能により、ツールおよびサブエージェントの進捗状況に対するサブスクリプションモデルを備えた、高度に並列化されたシステムへの対応が可能になりました。
- DeltaChannel は、長時間実行され長文脈を扱うエージェント向けのチェックポイントをサポートするストレージプリミティブを導入しました。
- ContextHubBackend: LangSmith Context Hub にバックアップされた、エージェントの動作を支えるファイルのためのバージョン管理されたホームであり、ランごとにコンテキストの改善を可能にします。
最新の Deep Agents をぜひお試しください。ご感想をお聞かせください！
リリースノート:
関連コンテンツ
Deep Agents
Managed Deep Agents の紹介
Victor Moreira
2026 年 5 月 13 日
5 分
Deep Agents
LangGraph
デルタチャネル：長期実行型エージェント向けランタイムの進化
シドニー・ランクル
2026 年 5 月 12 日
7 分
パートナー
Deep Agents
Deep Agents、LangSmith、Parallel を活用した企業デューデリジェンスエージェントの構築
M. ハリス、
N. マルティッチ、
S. タンゲディパッリ、
K. シング
2026 年 5 月 8 日
9 分
エージェントの実際の動作を確認する
LangSmith は、エージェントエンジニアリングプラットフォームであり、開発者がすべてのエージェントの意思決定をデバッグし、変更の評価を行い、ワンクリックでデプロイできるように支援します。
原文を表示
Key Takeaways
- Run capable agents on open-weight models — Harness profiles let you get production-grade performance from models like Kimi, Qwen, and DeepSeek at 20x+ lower cost than closed frontier APIs.
- Cut agent infrastructure costs at scale — Delta channels reduce checkpoint storage by up to 100x for long-running agents, without sacrificing observability or resilience.
- Build richer, real-time agent UIs — The new streaming primitive gives you typed, subscribable event projections for messages, tool calls, and subagents, from runtime all the way to the frontend.
The latest DeepAgents release is centered around performance at the model layer, the agent layer, at scale, and over time. Four things in this release contribute:
- Code interpreter: a lightweight runtime for agents to compose tools, manage state, and control what reaches model context — without the overhead of a full sandbox.
- Harness profiles: per-model tuning so your harness gets the most out of whichever model you're running, including open-weight models like Kimi, Qwen, and DeepSeek.
- Streaming: typed projections for messages, tool calls, subagents, and custom application events — subscribe to exactly what your application needs instead of parsing raw stream output.
- DeltaChannel: efficient checkpoint storage as agents run longer and context accumulates, without sacrificing the durable execution guarantees that make agents resumable, observable, and resilient.
- ContextHubBackend: backed by LangSmith Context Hub, store the skills, policies, and memories that shape agent behavior in a versioned, collaborative home, so what your agent learns from one run can improve the next.
Code interpreter
We’re releasing an installable code interpreter in Deep Agents, which give agents a programmable workspace where they can transform data, coordinate tool calls, and keep intermediate work out of the model context. The agent writes code to express its intent, then an in-memory runtime executes that code and returns the relevant results.
Where sandboxes are a code-first way for acting on an environment (such as running commands, installing dependencies, and editing files), interpreters are a code-first way for acting inside the agent loop: composing tools, preserving state, and deciding what information should be returned to the model.
1// Agent can write code like this:
2const topics = ["retrieval", "memory", "evaluation"];
3
4const reports = await Promise.all(
5 topics.map((topic) =>
6 tools.task({
7 description:
8 Research ${topic} in Deep Agents and return three concise findings.,
9 subagent_type: "general-purpose",
10 }),
11 ),
12);
13
14reports.join("\n\n");
This enables a few new novel capabilities for agents that we’re particularly excited about:
Model-agnostic PTC
Standard tool calling loops make the model the traffic controller for every step. The model asks for a tool, receives the full result in context, reasons over that result, and repeats. Even when an intermediate result is only needed to compute the next input, it still has to chain through multiple model calls.
Programmatic Tool Calling (PTC) changes that workflow. The model writes code that calls tools from inside an execution runtime, so workflows can run without a round-trip to a model for every individual tool invocation. Intermediate results can stay in runtime state where the interpreter can filter noisy outputs, process data, retry failures, and return only the relevant context back to the model.
1const pages = await Promise.all(
2 urls.map((url) => tools.fetchUrl({ url })),
3);
4
5const relevant = pages
6 .filter((page) => page.includes("interpreter"))
7 .slice(0, 3);
8
9relevant.map((page) => page.slice(0, 500));
This pattern of doing tool calling reduces token consumption, cuts down on avoidable model round trips, and makes the agent’s reasoning step smaller.
Anthropic helped popularize this pattern by adding it as an API behavior for their model family, but with an interpreter this can now be achieved by any agent with any model (including open source models).
Recursive workflows
Interpreters let agents interact with the harness in more novel ways. Because tools and subagents are callable from code, an agent can take the output of one subagent, inspect it, transform it, and feed it into another step without routing every intermediate artifact back through the main model.
That makes recursive workflows possible: the agent can keep a queue of questions, call a subagent on the next question, store the result, generate follow-up work from that result, and continue until it has enough evidence to synthesize an answer. (This is more than just “call another LLM on the full input context”: the key is maintaining working state outside the model context and controlling what gets passed into each next call.)
1const frontier = ["What changed in interpreter middleware?"];
2const findings = [];
3
4while (frontier.length && findings.length
<p>This is adjacent to the idea behind <strong>Recursive Language Models (RLM)</strong>: keep working state outside the model context, call models or subagents on selected branches, and control what enters the next model call.</p><p>In Deep Agents, the interpreter becomes the working runtime for that pattern — without claiming we “do RLM” as originally defined at the model layer.</p><p>All of this can be enabled by installing <code>deepagents[quickjs]</code> on pypi, or <code>@langchain/quickjs</code> on npm and adding it as a middleware</p>
1from deepagents import create_deep_agent
2from langchain_quickjs import REPLMiddleware
3
4agent = create_deep_agent(
5 model="baseten:zai-org/GLM-5",
6 middleware=[REPLMiddleware()],
7)
<p>See the <a href="https://docs.langchain.com/oss/python/deepagents/interpreters" data-wf-native-id-path="d6197e8f-aaf8-b075-5974-c4648a5d6cbf" data-wf-ao-click-engagement-tracking="true" data-wf-element-id="d6197e8f-aaf8-b075-5974-c4648a5d6cbf">docs</a> for more information on interpreters.</p></div></div><div id="harness-profiles"><h2>Harness profiles</h2><p>Open-weight models like Kimi K2.6, GLM 5.1, and DeepSeek V4 are now viable for production agent work, often at 20×+ lower cost than closed frontier models. But models are post-trained on different tool-calling format and prompt conventions, while most harnesses are tuned for the closed model their authors built against. Drop one in cold, and you might see only a fraction of its true capability because the model is speaking a dialect the harness doesn’t understand.</p><p>That gap is large and measurable. In our own testing, harness-layer changes alone moved <code>gpt-5.2-codex</code> from 52.8% → 66.5% on Terminal-Bench 2.0 (Top 30 → Top 5), lifted <code>gpt-5.3-codex</code> 20% on tau2-bench, and <code>opus-4.7</code> 10%. Across tau2-bench, prompts and middleware can move scores by 10 to 20 points without changing the model.</p><p>The "harness" is around the model: the base system prompt, tools and their descriptions, and middleware that shapes each turn. A harness profile captures these per-model overrides as a named, versionable unit.</p><p>DeepAgents v0.6 makes harness profiles a first-class abstraction. You can diff, version, and swap a profile alongside the model, so tuning work carries forward. We're shipping built-in profiles for major models so strong performance is the default, and the same machinery is available for your own stack.</p><p>More in <a href="https://www.langchain.com/blog/tuning-deep-agents-different-models" data-wf-native-id-path="d60ca3b7-3035-c91a-139d-b34da5a186f0" data-wf-ao-click-engagement-tracking="true" data-wf-element-id="d60ca3b7-3035-c91a-139d-b34da5a186f0">tuning deep agents across different models</a>. See the <a href="https://docs.langchain.com/oss/python/deepagents/profiles" data-wf-native-id-path="d60ca3b7-3035-c91a-139d-b34da5a186f3" data-wf-ao-click-engagement-tracking="true" data-wf-element-id="d60ca3b7-3035-c91a-139d-b34da5a186f3">docs</a> to write your own.</p></div><div id="streaming"><h2>Streaming</h2><p>Agents do a lot of work before they return a final answer. For a good user experience, you want to surface that work as it happens, and give users the ability to steer the agent along the way: streaming is the primitive that makes this possible. LangChain’s new release makes streaming a first-class application primitive. With <code>stream_events(..., version="v3")</code>, agents and graphs now emit a unified event stream with ergonomic projections for primitives developers actually want to render: message text, reasoning blocks, tool calls, state updates, subgraphs, subagents, custom channels, and final output. The stream is content-block-centric, which means UIs no longer need to guess whether a chunk is text, reasoning, media, or tool-call data. Everything is organized around typed events, namespaces, and channels, all aligned with the new <a href="https://github.com/langchain-ai/agent-protocol/tree/main/streaming" data-wf-native-id-path="d60ca3b7-3035-c91a-139d-b34da5a186fd" data-wf-ao-click-engagement-tracking="true" data-wf-element-id="d60ca3b7-3035-c91a-139d-b34da5a186fd">Agent Streaming Protocol</a>.</p>
1stream = agent.stream_events(
2 {"messages": [{"role": "user", "content": "Research LangChain streaming"}]},
3 version="v3",
4)
5
6for message in stream.messages:
7 for delta in message.text:
8 print(delta, end="", flush=True)
9
10for subagent in stream.subagents:
11 print(f"\\n[{subagent.name}] {subagent.status}")
12
13 for message in subagent.messages:
14 print(f"[{subagent.name}] ", end="")
15 for delta in message.text:
16 print(delta, end="", flush=True)
17 print()
<p>This streaming model also carries over the wire through new Agent Server endpoints and SDK support. The LangGraph SDK exposes remote event streaming through <code>client.threads.stream(...)</code>, with support for multimodal content, reconnect/replay behavior, and transport-agnostic delivery over SSE or WebSockets. Because local and remote streams now follow the same protocol, developers get a consistent way to observe agent runs across scripts, backend services, and production frontends. Applications can subscribe to exactly the parts of a run they need, such as messages from a specific subagent, updates from a custom channel, or events within a particular namespace.</p><p>On the frontend, this release brings v1 framework integrations for <code>@langchain/react</code>, <code>@langchain/vue</code>, <code>@langchain/svelte</code>, and <code>@langchain/angular</code>, giving teams idiomatic hooks and utilities for building rich streamed experiences without hand-rolling event parsers. To make the new stack easy to explore, we’re also publishing the <a href="https://github.com/langchain-ai/streaming-cookbook" data-wf-native-id-path="1c0d7427-e1b3-7da0-4bb4-20a1ba87bcb2" data-wf-ao-click-engagement-tracking="true" data-wf-element-id="1c0d7427-e1b3-7da0-4bb4-20a1ba87bcb2">Streaming Cookbook</a>: a collection of runnable examples covering message streaming, subgraphs, subagents, custom stream transformers, multimodal UI, reconnect behavior, and framework-specific patterns. The result is a streaming foundation that is lower-level where you need precision, higher-level where you want productivity, and consistent from agent runtime to user interface.</p></div><div id="delta-channels"><h2>Delta channels</h2><p>Deep Agents is built on the LangGraph runtime, which checkpoints agent progress at every step. That's what makes observability, human-in-the-loop, and failure recovery possible: you always know exactly where an agent is and can resume from any point.</p><p>As agents get more capable:</p><ol role="list"><li>They run longer, with message histories that grow across dozens or hundreds of steps</li><li>They use more context, utilizing the filesystem for context management and offloading</li></ol><p>For deepagents, message history and files live in agent state, and with a snapshot-every-step approach, checkpoint storage grows at O(N²).</p><p>Delta channels are how we're evolving the runtime to keep up. Rather than serializing a full snapshot at every checkpoint, we store only the diff. For Deep Agents, that means delta-based storage for message histories and files.</p><p></p><figure><p><img alt="" src="https://cdn.prod.website-files.com/65c81e88c254bb0f97633a71/6a029525790bff5c3e6d132d_delta_channel_card_v2%20(1)%20(1).svg" loading="eager"></p></figure><p>You still get a complete history of agent progress, just at a fraction of the storage cost. This also helps to mitigate the bottleneck of writes to the checkpointer (database) for long-running agents, and storage costs at scale are much more manageable.</p><p>Depending on the conversation length and context size, swapping to delta channels can reasonably bring 10-100x reductions in checkpointer storage.</p><p>Consider, for example, an experiment: a simulated multi-file coding session where an agent writes files, retrieves documentation, and reasons through its work — 200 turns of the kind of sustained, context-heavy work a capable coding agent actually does. Without delta channels, that session accumulates <strong>5.27 GB</strong> of checkpoint storage. With delta channels: <strong>129 MB</strong>.</p><p>Here’s a comparison of checkpointer storage for the same agent with and without delta channels:</p><figure><p><img alt="" src="https://cdn.prod.website-files.com/65c81e88c254bb0f97633a71/6a0296bb2b7db2e536d0d613_table_workload_b%20(2)%20(1).svg" loading="eager"></p></figure><p>And a graphical representation of said explosion:</p><figure><p><img alt="" src="https://cdn.prod.website-files.com/65c81e88c254bb0f97633a71/6a0296c77f447828189b0736_chart_workload_b%20(1).svg" loading="eager"></p></figure><p>Long-running agents with deep context are where the field is heading, and delta channels are how our runtime scales to meet their needs.</p><p>See the <a href="https://www.langchain.com/blog/delta-channels-evolving-agent-runtime" data-wf-native-id-path="fc2402ca-e172-fc01-0944-b06acfad5f8f" data-wf-ao-click-engagement-tracking="true" data-wf-element-id="fc2402ca-e172-fc01-0944-b06acfad5f8f">full writeup</a> for more details.</p></div><div id="contexthub-backend"><h2>ContextHub Backend</h2><p>Context Hub is a LangSmith-backed filesystem for Deep Agents. It gives you a versioned place for the files that shape agent behavior, so improvements to prompts, skills, and other context can carry forward across runs.</p><p>Under the hood, your agent reads from (and can write to) a Hub repo. Those writes land as commits with history, review, and environment tagging—so you can iterate in staging and promote to production without wiring up a separate storage layer.</p><figure><p><img alt="" src="https://cdn.prod.website-files.com/65c81e88c254bb0f97633a71/6a02201c12822b49ff00901d_context-hub-1.png" loading="eager"></p></figure><p>To use it as your agent's filesystem backend:</p>
1from deepagents import create_deep_agent
2from deepagents.backends import ContextHubBackend
3
4agent = create_deep_agent(
5 model="google_genai:gemini-3.1-pro-preview",
6 backend=ContextHubBackend("my-agent"),
7)
<p>Or scope just /memories/ to Hub while keeping the rest of the filesystem thread-scoped:</p>
1from deepagents.backends import CompositeBackend, StateBackend, ContextHubBackend
2
3agent = create_deep_agent(
4 model="google_genai:gemini-3.1-pro-preview",
5 backend=CompositeBackend(
6 default=StateBackend(),
7 routes={
8 "/memories/": ContextHubBackend("my-agent"),
9 },
10 ),
11)
Reads are served from cache, and writes are committed back to the Hub repo. If the repo doesn’t exist yet, the first write creates it—after that, you can diff, review, and tag changes like any other piece of versioned context.
Set `LANGSMITH_API_KEY` before using `ContextHubBackend`. See the [full docs](https://docs.langchain.com/oss/python/deepagents/backends#contexthubbackend) for conflict handling and limits.
## Wrapping up
The through-line across our Deep Agents May release is performance:
- Harness profiles help you squeeze performance out of a model with an optimal harness and unlock viable agent runs on open-weight models at a fraction of the cost of frontier APIs
- Code interpreter gives an agent more autonomy to write an execute code, helping it accomplish complex tasks and optimize context window usage.
- Streaming enables support for highly parallelized systems with a subscription model for tool and subagent progress.
- DeltaChannel introduces a storage primitive that supports checkpoints for long-running, long-context agents.
- ContextHubBackend: a versioned home for the files that power agent behavior, backed by LangSmith Context Hub, enables context improvements from one run to the next.
We’re excited for you to give the latest `deepagents` a spin. Let us know what you think!
Release notes:
[Python](https://docs.langchain.com/oss/python/releases/changelog)
[](https://docs.langchain.com/oss/python/releases/changelog)[TypeScript](https://docs.langchain.com/oss/javascript/releases/changelog)
### Related content
Deep Agents
### Introducing Managed Deep Agents
Victor Moreira
May 13, 2026
5
min
Deep Agents
LangGraph
### Delta Channels: Evolving our Runtime for Long-Running Agents
Sydney Runkle
May 12, 2026
7
min
.png)
Partner
Deep Agents
### Building a company due diligence agent with Deep Agents, LangSmith and Parallel
M. Harris,
N. Martitsch,
S. Tangedipalli,
K. Singh
May 8, 2026
9
min
### See what your agent is really doing
LangSmith, our agent engineering platform, helps developers debug every agent decision, eval changes, and deploy in one click.関連記事
今日のまとめ
AI日報で今日の重要ニュースをまとめ読み