Skip to content
CAI
Software that uses CAICheck a score

langchain-ai/deepagents

63.4

Weak · 4 November 2026

263.9k

lines of production code

Python

primary language

4

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add RubricMiddleware example with LangSmith tracing

Added a runnable example in \examples/rubric\_middleware\ that demonstrates the \RubricMiddleware\ end-to-end with real models. The script runs an agent that drafts a document, uses a grader model to score it against a rubric, and iteratively revises the output until all criteria are satisfied or the iteration budget is exhausted. It includes full LangSmith tracing to visualize the grading payloads, frozen criterion checklists, and revision prompts injected back into the agent.

_examples/rubric\middleware · high confidence

Add content-builder-agent example demonstrating file-based agent configuration

Introduces a new example agent that writes blog posts, LinkedIn posts, and tweets with generated cover images. The agent is configured entirely through filesystem primitives—\AGENTS.md\ for brand voice, \skills/\ for task-specific workflows, and \subagents.yaml\ for delegated research tasks—wired together in \content\_writer.py\ using the \deepagents\ SDK and \FilesystemBackend\. It includes tools for web search (via Tavily) and image generation (via Google Gemini), with output saved to local directories.

examples/content-builder-agent · high confidence

Add standalone better-harness example for autonomous agent optimization

Introduces a new \better-harness\ example in \examples/better-harness\ that demonstrates how to use an outer Deep Agent to autonomously optimize an inner agent's harness. The example provides a complete Python package (\better\_harness\) with core data models, patching logic for module attributes and workspace files, and runners for pytest and Harbor. It includes a worked configuration (\examples/deepagents\_example.toml\) showing how to expose editable surfaces like prompts, tools, skills, and middleware, and documents the optimization loop that iterates through diagnosis, proposal, evaluation, and acceptance to improve agent performance.

examples/better-harness · high confidence

Add text-to-SQL Deep Agent example

Introduces a new example in \examples/text-to-sql-agent\ demonstrating a LangChain Deep Agent that converts natural language questions into SQL queries against a Chinook SQLite database. The agent uses Claude Sonnet 4.5, supports planning via \write\_todos\, and leverages filesystem-based memory and skills for context management. It includes a CLI entry point (\agent.py\), configuration via \.env\, and safety rules restricting access to read-only SELECT operations.

examples/text-to-sql-agent · high confidence

Added import validation script for pre-commit checks

A new Python script, \check\_imports.py\, has been added to the \libs/deepagents/scripts\ directory. This utility verifies that specified Python files can be loaded by the interpreter without errors, printing tracebacks for any failures. It is designed to be used in Makefiles and pre-commit hooks to quickly catch import issues before running more expensive tests.

libs/deepagents/scripts · high confidence

Enforced branch naming convention via pre-push hook

A new pre-push hook has been added to enforce the repository's branch naming convention, requiring branches to follow the format \\<github-username\>/\<scope\>/\<short-description\>\. The script automatically resolves the contributor's GitHub username (via git config, the GitHub CLI, or email fallback) and validates that the branch scope is in the allowed list (e.g., acp, ci, deepagents, docs). This local check complements the server-side CI validation in \.github/workflows/branch\_name\_check.yml\, helping developers catch naming errors before pushing.

.githooks · high confidence

Introduce ACP server implementation for Deep Agents

Added a new ACP (Agent Client Protocol) server implementation in \libs/acp/deepagents\_acp/server.py\ that enables Deep Agents to communicate via the ACP standard. The server handles session initialization, configuration, and streaming of agent messages, thoughts, and tool calls, while ensuring compatibility with ACP schema versions 0.8.x and 0.9.0+ through dynamic resolution of config option wrappers.

deepagents-acp · high confidence

Introduce ContextHubBackend for persistent file storage in LangSmith Hub

Agents can now use the new \ContextHubBackend\ to store and retrieve files directly within a LangSmith Hub agent repository. This backend provides a persistent, versioned file store that integrates with the existing \BackendProtocol\, allowing conversation history and tool artifacts to be saved to a remote hub rather than local state or filesystem. It supports standard file operations (read, write, edit, delete, glob, grep) and handles conflict resolution and mutation queuing for concurrent access.

deepagents · high confidence

Introduce Daytona sandbox backend for Deep Agents

Added the \langchain-daytona\ partner package (version 0.0.8) which provides a \DaytonaSandbox\ implementation of the \BaseSandbox\ protocol. This allows Deep Agents to execute shell commands and manage files within Daytona sandboxes, supporting configurable command timeouts and flexible polling intervals for asynchronous command completion.

_libs/partners/daytona/langchain\daytona · high confidence

Introduce Deep Agents ACP integration for editor-based agents

Adds a new \libs/acp\ package that implements the Agent Client Protocol (ACP) for Deep Agents, enabling users to run Deep Agents as ACP servers in compatible text editors like Zed. The release includes an example coding agent (\deepagents-acp\), support for persistent session loading via durable LangGraph checkpointers, and dynamic model switching capabilities. It also provides a prebuilt \dcode --acp\ mode for the terminal coding agent and includes necessary build infrastructure (Makefile, \.env.example\, and MIT license).

libs/acp · high confidence

Introduce Deep Agents ACP library with shell command security controls

The \libs/acp/deepagents\_acp\ package is added, providing an Agent Client Protocol integration for Deep Agents. This includes utilities to convert ACP content blocks (text, images, resources) into LangChain formats and a test server entry point. Crucially, the library implements security measures for command auto-approval: it blocks dangerous shell patterns (such as command substitution, redirects, and background execution) to prevent injection attacks and extracts specific command signatures (e.g., \python -m\, \npm install\) to ensure precise permissioning.

_libs/acp/deepagents\acp · high confidence

Introduce ModalSandbox backend for Deep Agents

Users can now run Deep Agents inside Modal sandboxes by using the new \ModalSandbox\ class from the \langchain\_modal\ partner package. This implementation conforms to the \BaseSandbox\ protocol, allowing agents to execute shell commands with configurable timeouts and perform file uploads and downloads within the sandbox environment.

_libs/partners/modal/langchain\modal · high confidence

Introduce NVIDIA Deep Agent example with GPU-accelerated data skills

Adds a new example demonstrating a multi-model deep agent architecture that uses a frontier model as an orchestrator and NVIDIA Nemotron Super for research. The example includes a data-processor subagent capable of GPU-accelerated data analysis (cuDF), machine learning (cuML), and visualization (matplotlib/seaborn) via a Modal sandbox. It provides configuration for orchestrator models (Anthropic, OpenAI, Google), API keys for NVIDIA, Tavily, and LangSmith, and specific skill definitions for cudf-analytics, cuml-machine-learning, data-visualization, and gpu-document-processing.

_examples/nvidia\_deep\agent · high confidence

Introduce Python extension system for agent customization

The agent runtime now supports Python extensions, allowing users to register custom tools, LangChain middleware, and backend routes. This feature is gated by the EXPERIMENTAL environment variable and the \[extensions\] configuration section. Extensions are discovered from user directories, project directories, CLI paths, and entry points, with a trust policy governing project-authored code. Registered tools are injected dynamically at runtime via middleware, and backend routes are validated against protected internal paths and sandbox restrictions.

_libs/code/deepagents\code/extensions · high confidence

Introduce Runloop sandbox integration for Deep Agents

This change adds the \langchain-runloop\ partner package, providing \RunloopProvider\ and \RunloopSandbox\ classes that allow Deep Agents to create, attach to, and execute commands within Runloop devboxes. The provider supports bootstrapping sandboxes from named blueprints (with automatic Dockerfile building if missing) or attaching to existing devboxes by ID, while the sandbox backend implements standard file upload/download and command execution capabilities.

_libs/partners/runloop/langchain\runloop · high confidence

Introduce Talon local runtime host for long-running Deep Agents

This change introduces the Talon local runtime host, a new experimental component for managing long-running Deep Agents. It provides a CLI entry point (\\_\main\\_.py\) to launch the host with optional channel adapters for Slack, Discord, Telegram, and WhatsApp, and supports importing Fleet zip exports. The runtime includes a configurable conversation archive system (\archive.py\, \archive\saver.py\) that persists chat history using LangGraph checkpointers (SQLite, Postgres, MongoDB) and exposes agent-facing tools for searching and reading conversation history. It also features a background subagent middleware (\background.py\) for running expendable tasks asynchronously, a cron scheduler (\cron.py\) for scheduled jobs, and a current time tool (\clock.py\). The module exposes a public API via \\\init\\_.py\ including interfaces for agent requests, channel adapters, and tool approvals, along with configuration management (\config.py\) and checkpoint backend selection (\checkpoint\_backends.py\).

_libs/talon/deepagents\talon · high confidence

Introduce WhatsApp bridge with message context, self-chat restrictions, and media handling

This change adds the WhatsApp bridge implementation (bridge.js, id\_compat.js, media.js) to the Talon channel system. It enables the bridge to preserve quoted message context, restrict replies to self-chats, handle message reactions, and download media while preserving MIME types. The bridge also ensures compatibility with WhatsApp's message key structure and manages session and media storage via environment-configurable paths.

_libs/talon/deepagents\_talon/channels/whatsapp\bridge · high confidence

Introduce beta model and harness profile APIs

The \deepagents.profiles\ package is now available as a public beta API, allowing users to tailor Deep Agents behavior through two distinct profile types: \ProviderProfile\ for controlling model construction (e.g., \init\_chat\_model\ kwargs) and \HarnessProfile\ for controlling runtime agent behavior (e.g., prompt assembly, tool visibility). The package includes built-in profiles for providers like OpenAI, Anthropic, and NVIDIA, as well as a lazy-loading bootstrap system that supports third-party plugin registration via \importlib.metadata\ entry points. Users can register custom profiles using \register\_provider\_profile\ and \register\_harness\_profile\, which merge additively on existing keys.

libs/deepagents/deepagents/profiles · high confidence

Introduce dedicated channel adapters and authorization framework for Slack, Discord, and Telegram

Talon now includes dedicated channel adapters for Slack, Discord, and Telegram, enabling users to interact with the agent directly within these platforms. This change introduces a new authorization framework (\authorization.py\) to manage OAuth flows and sender pairing securely across all channels. Users gain access to platform-specific features such as slash commands on Discord, thread history and media handling on Slack, and reaction-based approvals on Telegram, all governed by configurable exposure policies and sender pairing codes. Also in this area: 1 commit (0 fixes) modifying deepagents-talon, libs/talon; 3 commits (1 fix) modifying deepagents-talon.

_deepagents-talon, libs/talon/deepagents\talon/channels · medium confidence

Introduce headless client and session cost tracking

Adds a new \client\ package providing non-interactive execution mode for running agent tasks via command line, along with a remote client wrapper for server communication and a session cost tracker that combines main-task and side-question usage for display.

_libs/code/deepagents\code/client · high confidence

Introduce in-app Debug Console and runtime context types

Adds an in-app Debug Console (accessible via Ctrl+\\) backed by an in-memory ring buffer that partitions log retention by level so high-volume DEBUG output does not evict INFO/WARNING/ERROR records. Introduces lightweight runtime context types (\CLIContextSchema\, \CLIContext\) for per-run graph overrides (model swap, approval mode, summarization model) extracted from the langchain middleware stack to reduce startup import latency. Includes supporting modules for dependency floor checks on editable installs, git metadata helpers, and immutable filesystem path snapshots. Also in this area: 1 commit (1 fix) fixing deepagents-code, libs/code; 12 commits (8 fixes) fixing deepagents-code; Introduce plugin marketplace and management system.

deepagents-code · medium confidence · unverified

Introduce middleware package with filesystem, memory, skills, and subagent capabilities

The \deepagents.middleware\ package is now available, providing a structured set of middleware components for the Deep Agents SDK. This includes \FilesystemMiddleware\ for managing file access with configurable permissions and human-in-the-loop interrupt modes, \MemoryMiddleware\ for loading and injecting context from AGENTS.md files, \SkillsMiddleware\ for on-demand skill loading, and \SummarizationMiddleware\ for context window management. The package also introduces \AsyncSubAgentMiddleware\ for remote agent coordination, \RubricMiddleware\ for self-evaluation, and utilities for blob offloading, video frame extraction, and prompt caching.

libs/deepagents/deepagents/middleware · high confidence

Introduce persistent QuickJS REPL middleware with subagent orchestration and PTC

This release adds the \langchain\_quickjs\ package, providing a \CodeInterpreterMiddleware\ that embeds a persistent QuickJS JavaScript REPL into LangChain agents. The middleware enables Programmatic Tool Calling (PTC), allowing models to invoke agent tools directly as JavaScript functions (e.g., \tools.search()\) within a single eval call, bypassing the serial tool-call loop. It also introduces a \task()\ global for dispatching subagents from inside the REPL, supporting structured \responseSchema\ outputs, concurrency limits, and live streaming events (\SubagentStartEvent\, \SubagentCompleteEvent\, \SubagentErrorEvent\) for UI integration. To manage state efficiently, the REPL uses delta-encoded snapshot persistence (via \bsdiff4\ patch chains) and includes HMAC-based integrity verification for stored snapshots.

_libs/partners/quickjs/langchain\quickjs · high confidence

Introduce persistent cron scheduling for Talon agents

This change adds a new cron scheduling subsystem to Talon, enabling agents to create, edit, and manage background jobs via \CronTools\. Users can schedule tasks using relative intervals (e.g., \every 15m\), wall-clock times with timezone awareness (e.g., \daily at 08:00 America/New\_York\), or standard five-field cron expressions. Jobs support recurring execution with optional caps (\repeat\_times\) and expiration (\until\), and results can be delivered to either the originating thread or the parent channel. The system includes a persistent store for job state, a resilient scheduler that survives tick failures, and the ability to pin specific skills to scheduled runs.

_libs/talon/deepagents\talon/cron · high confidence

Introduce pluggable memory backend system

Adds a new \deepagents.backends\ package that provides a unified protocol for pluggable file storage backends. This includes \FilesystemBackend\ for direct local file access, \StateBackend\ for ephemeral storage within LangGraph agent state, \StoreBackend\ for persistent storage with namespace support, \ContextHubBackend\ for storing files in a LangSmith Hub agent repo, \LangSmithSandbox\ for sandboxed file operations, \LocalShellBackend\ for unrestricted local shell execution, and \CompositeBackend\ for routing file operations by path prefix to different backends.

libs/deepagents/deepagents/backends · high confidence

Introduce pluggable sandbox provider architecture

The \deepagents\_code/integrations\ module now provides a unified, pluggable backend for sandbox environments. Users can configure sandbox providers via the \\[sandboxes\]\ section in \\~/.deepagents/config.toml\, specifying a default provider and a list of providers with their class paths, working directories, and parameters. The system supports built-in providers (such as \agentcore\, \daytona\, \langsmith\, \modal\, \openshell\, \runloop\, and \vercel\) as well as third-party providers discovered via entry points or declared in the config. This change enables users to select and switch between different sandbox backends, manage sandbox lifecycles (creation, connection, cleanup), and leverage features like sandbox snapshots where supported by the provider.

_libs/code/deepagents\code/integrations · high confidence

Introduce plugin marketplace and management system

Adds a new plugin ecosystem to deepagents-code, enabling users to discover, install, enable, and uninstall plugins from configurable marketplaces (local directories, GitHub repositories, Git URLs, or JSON endpoints) via a new \plugin\ CLI command. The implementation includes marketplace source parsing with credential redaction, manifest-based component discovery (skills, MCP servers, hooks, Python extensions), versioned installation caching, and state persistence for installed plugins and marketplace records. Also in this area: 1 commit (0 fixes) modifying libs/code/deepagents\_code/plugins.

_libs/code/deepagents\code/plugins · medium confidence · unverified

Introduce sandboxed JavaScript code execution via QuickJS middleware

Adds a new \CodeInterpreterMiddleware\ that exposes a sandboxed JavaScript REPL (via the \quickjs-rs\ engine) to LangChain agents. This enables models to execute JavaScript code through an \eval\ tool, with configurable safety limits including memory usage, execution timeout, and a budget for programmatic tool calls (PTC). The middleware supports persistent state across turns, console output capture, and optional subagent task dispatching, providing a flexible environment for code-based reasoning and tool orchestration.

langchain-quickjs · high confidence

Introduce standalone \`libs/evals\` package with unified CLI and documentation

The eval suite is now a standalone package (\libs/evals\) with a new \deepagents-evals\ console script that replaces the previous Makefile-only workflow. Users can now discover available models, categories, and tiers via \deepagents-evals list\, run single trials or multi-trial aggregations with \deepagents-evals run\ and \trials\, and generate radar charts or check catalog drift. The package includes comprehensive documentation (\AGENTS.md\, \CONTRIBUTING.md\) explaining the two-tier assertion model, required environment variables (LangSmith tracing), and the structure of the \trials\_summary.json\ output.

libs/evals · high confidence

Introduce standalone evals library with multi-trial runner, LLM-as-judge, and curated benchmarks

The \deepagents-evals\ package is consolidated into a standalone library (\libs/evals\) that provides a unified evaluation infrastructure. Users can now run repeated trials with the new \run\_trials.py\ script to aggregate mean, median, and standard deviation across runs, and analyze results with \analyze.py\. Evaluation logic is modernized by replacing the custom LLM judge with the \openevals\ library, enabling concurrent criterion grading and tool-call context inclusion. The suite includes a new \tau3\_subset\ dataset stratified by difficulty (easy, medium, hard) and integrates external benchmarks (FRAMES, Nexus, BFCL v3) and MemoryAgentBench. Visualization is handled by a new \radar.py\ module that generates per-model spider charts with light/dark themes, and the airline domain is reimplemented as a self-contained module for tau2/tau3 benchmarking.

deepagents-evals · high confidence

Introduces built-in harness profiles for Anthropic, OpenAI, and NVIDIA models

Adds a new \harness\ profile package that registers built-in system-prompt suffixes and middleware for specific model families. This includes profiles for Anthropic models (Claude Haiku 4.5, Sonnet 4.6, and Opus 4.7) that enforce parallel tool calls, grounded investigation, and reflection; an OpenAI Codex profile (GPT-5.1/5.2/5.3) that enforces autonomous senior-engineer behavior and TODO hygiene; and an NVIDIA Nemotron 3 Ultra profile that includes middleware to fix filesystem tool-call argument quirks and handle read-file result formatting.

libs/deepagents/deepagents/profiles/harness · high confidence

New ACP demo agent with local context middleware and multi-model support

The ACP examples now include a new demo coding agent (\demo\_agent.py\) that integrates with the ACP server, featuring a \LocalContextMiddleware\ (\local\_context.py\) to automatically detect and inject project details (language, package manager, git state) into the agent's system prompt. The demo supports dynamic model switching across Anthropic (Claude Opus/Sonnet/Fable/Haiku 5.x), OpenAI (GPT 6.x/5.x), and Baseten providers, and allows users to configure session modes (e.g., 'Ask before edits', 'Accept everything') to control permission prompts for file and shell operations.

libs/acp/examples · high confidence

New CLI commands for auth, config, install, MCP, and tools

The \dcode\ CLI now exposes dedicated subcommands for managing credentials (\auth list/set/remove/status\), inspecting configuration options and their sources (\config get/show\), installing optional extras (\install\), managing Model Context Protocol servers (\mcp login/config\), and listing available agent tools (\tools list/install\). These commands provide non-interactive, scriptable access to capabilities previously only available through the Textual UI, including secure credential storage, verbose config resolution reporting, and tool catalog enumeration.

_libs/code/deepagents\code/client/commands · high confidence

New Deep Research example with LangGraph and Tavily integration

Added a new \deep\_research\ example in the \examples/deep\_research\ directory that demonstrates a multi-agent research workflow using the \deepagents\ package. The example includes a LangGraph server configuration (\langgraph.json\) and a standalone agent script (\agent.py\) that orchestrates a main agent delegating tasks to a research sub-agent. It integrates the Tavily API for web search (\tavily\_search\ tool) and a custom \think\_tool\ for strategic reflection, with configurable limits on concurrent sub-agents and search iterations. The package also provides a Jupyter notebook (\research\_agent.ipynb\) for interactive exploration, along with prompt templates (\prompts.py\) defining the research workflow, delegation strategies, and hard limits to prevent excessive tool usage. An \.env.example\ file documents the required API keys for Anthropic, OpenAI, Tavily, and LangSmith.

_examples/deep\research · high confidence

New LLM Wiki example with persistent, syncable knowledge base

Added a new script-first Deep Agents example that builds and maintains a persistent wiki, syncing updates through LangSmith Context Hub. The example provides a CLI runner with four modes: \init\ to set up the workspace and enforce internal repo source, \ingest\ to process source material into canonical wiki pages (with an optional human-in-the-loop review step), \query\ to answer questions grounded in the wiki with optional durable filing of answers, and \lint\ to perform health checks, reconcile contradictions, and fix orphan pages. It includes a structured, append-only interaction log (\log.md\) and a categorized content catalog (\wiki/index.md\) to support navigation and retrieval.

examples/llm-wiki · high confidence

New Python infrastructure scripts for dependency management, release notes, and unified evaluation aggregation

This change introduces a suite of new Python scripts under \.github/scripts/\ that enhance CI/CD workflows and evaluation capabilities. The \release/\ directory adds \raise\_langchain\_minimums.py\ to automatically update lower-bound dependencies for the LangChain ecosystem, \check\_dep\_freshness.py\ to detect outdated dependency minimums, \check\_release\_deps.py\ to validate release PR dependencies against PyPI, and \build\_release\_notes.py\ to locally reconstruct GitHub release bodies. The \evals/\ directory adds a unified evaluation framework including \models.py\ for a centralized model registry, \aggregate\_shards.py\ for computing pass@K and avg@K metrics from shard results, \aggregate\_unified.py\ for cross-model comparison and leaderboards, \aggregate\_unified\_compare.py\ for branch/config comparisons, \collect\_langsmith\_usage.py\ for token and cost tracking, and \unified\_types.py\ for shared data structures.

python · high confidence

New Ralph Mode example with non-interactive CLI support

Added a new \examples/ralph\_mode\ directory containing a Python script and documentation for the 'Ralph' autonomous looping pattern. This example allows users to run the Deep Agents CLI in a non-interactive loop where each iteration starts with fresh context while persisting filesystem changes, supporting options for iteration limits, model selection, remote sandboxes (AgentCore, Modal, Daytona, Runloop), and shell command allow-lists.

_examples/ralph\mode · high confidence

New TUI modals for cost, context, and side conversations

The TUI now includes several new modal dialogs to improve user control and transparency: a side-conversation modal (/btw) for independent questions, a prompt clipboard for searching and reusing previous inputs, and a detailed cost-breakdown view that refreshes while open. Users are also warned before expensive cold-cache turns, must confirm model switches with large context, and are prompted to compact large resumed threads or handle blocked resumption. A persistent session-cost warning ensures users are notified when spending exceeds configured thresholds.

_libs/code/deepagents\code/tui/modals · high confidence

New built-in thread inspector skill for local session analysis

A new built-in skill, \deepagents-thread-inspector\, has been added to allow users to inspect and explain conversations stored in the local Deep Agents Code SQLite session store. This tool serves as a fallback when LangSmith trace tooling is unavailable, supporting offline or untraced sessions. It enables users to look up current thread titles (including manual renames), list recent threads, and inspect checkpoint metadata by reading the local \sessions.db\ file via the \inspect\_sessions.py\ script. The skill respects the \DEEPAGENTS\_HOME\ environment variable for database location and ensures read-only access to prevent accidental mutation of session data.

_libs/code/deepagents\_code/built\_in\skills/deepagents-thread-inspector · high confidence

New coding agent deployment example with structured skills

Added a new \examples/deploy-coding-agent\ directory that demonstrates deploying an autonomous coding agent using \deepagents deploy\. The example includes an \agent.json\ configuration targeting the \anthropic:claude-sonnet-4-5\ model, environment variable templates for Anthropic and LangSmith API keys, and a set of agent skills (\code-review\, \coding-prefs\, \planning\) that define the agent's workflow, coding standards, and review processes. Documentation files (\README.md\, \AGENTS.md\) explain how to deploy the agent and interact with it via the LangGraph SDK.

examples/deploy-coding-agent · high confidence

New developer documentation for the \`libs/code\` package

Added \AGENTS.md\, \ARCHITECTURE.md\, \COMMANDS.md\, and \DEVELOPMENT.md\ to \libs/code\ to guide contributors. These files document the package's Textual-based terminal UI conventions, client/server architecture, slash command catalog, and local development setup (including \uv\ bootstrapping, debugging, and LangSmith tracing configuration).

libs/code · high confidence

New developer tooling scripts and hardened installer for deepagents-code

This change introduces several new scripts in \libs/code/scripts\ to improve the developer experience and installation robustness. The \install.sh\ script has been significantly enhanced with support for pre-release dependencies, explicit version pinning, configurable extras (model providers, sandboxes, integrations), and a new \DEEPAGENTS\_HOME\ environment variable for user data. It also includes hardened download verification, automatic PATH setup, and quieter default output. Additionally, \check\_imports.py\ provides a fast import-verification tool for CI/Makefiles, \check\_process\_cwd.py\ enforces correct working-directory usage across the codebase via an allowlist, \generate\_commands\_catalog.py\ auto-generates the slash-command reference documentation, and \debug\_server.sh\ assists in diagnosing server startup failures.

libs/code/scripts · high confidence

New example skills and extension infrastructure

Adds example skills for arXiv search, LangGraph documentation lookup, and web research, along with a skill-creator template and validation scripts to guide skill development. Introduces a memory store extension example that registers a virtual storage route at \/memories/\ using the \StoreBackend\.

libs/code/examples · high confidence

New interactive plugin manager screen

A new TUI modal screen is introduced for managing plugins, accessible via the \/plugins\ command. It provides a tabbed interface with five sections: Discover (browse available plugins), Installed (manage enabled/disabled state and uninstall), Marketplaces (add or remove plugin sources), Errors (view loading issues), and Settings (configure auto-update). The screen supports keyboard navigation, search filtering, and displays detailed status for each plugin, including MCP connection state, skill counts, and hook events. It also allows previewing plugin contents before installation and handles reload prompts when plugin state changes.

_libs/code/deepagents\_code/tui/modals/plugin\manager · high confidence

New self-hosted async subagent server example

Added a new example in \examples/async-subagent-server\ that demonstrates how to host a Deep Agents researcher as an async subagent using the Agent Protocol. The example includes a FastAPI server (\server.py\) implementing the required endpoints (create thread, start run, poll status, cancel, etc.) with in-memory SQLite persistence, and a supervisor REPL (\supervisor.py\) that connects to the server to delegate research tasks. It also provides an \.env.example\ for configuration (API keys, port) and \test\_server.py\ with end-to-end tests for the HTTP contract.

examples/async-subagent-server · high confidence

New skill-creator built-in skill with scaffolding and validation tools

A new built-in 'skill-creator' skill has been added to guide users in creating, structuring, and validating agent skills. It includes a comprehensive SKILL.md defining skill anatomy, precedence rules (built-in, user, project), and design principles like progressive disclosure. It also ships with two executable scripts: \init\_skill.py\ to scaffold new skills from a template with standard directories (scripts, references, assets), and \quick\_validate.py\ to validate SKILL.md frontmatter against the SDK spec (checking required fields, name format/length, description limits, and allowed properties).

_libs/code/deepagents\_code/built\_in\skills/skill-creator · high confidence

New skills management CLI and trust system

Adds a new skills module providing CLI commands to list, create, info, and delete skills, with support for discovering skills from built-in, user, project, and plugin sources. Introduces an in-the-moment trust prompt for symlinked skills, persisting user approvals in a local trust store to allow reading SKILL.md files from resolved directories outside standard trusted roots, while enforcing path containment to prevent symlink traversal attacks.

_libs/code/deepagents\code/skills · high confidence

Architecture

Deep Agents Code restructured into a standalone package

The \libs/code/deepagents\_code\ directory has been reorganized into a proper Python package (\deepagents\code\). This introduces a formal entry point via \\\main\\_.py\ (allowing \python -m deepagents\_code\) and implements lazy loading for the CLI to improve startup performance. The codebase now includes dedicated modules for environment variable management (\\_env\_vars\), debug logging configuration (\\_debug\), and shared constants (\\_constants\), establishing a cleaner internal structure for the interactive coding assistant.

_libs/code/deepagents\code · high confidence

Extract TUI widgets into a dedicated package

The Textual UI components (such as the chat input, approval menu, agent selector, and authentication screens) have been moved from the application root into a new \deepagents\_code.tui.widgets\ package. This refactoring centralizes the UI logic, making the codebase easier to maintain and allowing the widgets to be imported directly from the new submodule. Also in this area: 5 commits (3 fixes) fixing libs/code/deepagents\_code/tui; Introduce in-app Debug Console and runtime context types; Textual UI widgets moved into a dedicated \tui\ package.

_libs/code/deepagents\code/tui/widgets · medium confidence · unverified

Behavioural changes

114 commits (0 fixes) modifying libs/partners/vercel

A change to existing behaviour in libs/partners/vercel — 114 commits, 14 files: “release(deepagents): 0.7.2 (\#5230)”; “release(deepagents): 0.7.16 (\#6372)”; “release(deepagents-code): 0.1.31 (\#4424)”; and 111 more (refs \#5230, \#6372, \#4424, \#6310, \#7136, …).

libs/partners/vercel · medium confidence · unverified

14 commits (5 fixes) modifying libs/code/deepagents\_code/plugins/adapters

A change to existing behaviour in libs/code/deepagents\_code/plugins/adapters — 14 commits (5 fixs), 5 files: “feat(code): add plugin marketplace support (\#4554)”; “feat(code): resolve and trust-check invoked skills on the server (\#6837)”; “feat(code,talon): require Python 3.12 or greater (\#5603)”; and 11 more (refs \#4554, \#6837, \#5603, \#5198, \#7010, …).

_libs/code/deepagents\code/plugins/adapters · medium confidence · unverified

38 commits (16 fixes) modifying libs/code/deepagents\_code/client/launch

A change to existing behaviour in libs/code/deepagents\_code/client/launch — 38 commits (16 fixs), 4 files: “feat(code,talon): require Python 3.12 or greater (\#5603)”; “feat(code): selectable model for the Auto approval classifier (\#5205)”; “fix(code): stop the local server from uploading usage metadata to LangSmith (\#7252)”; and 35 more (refs \#5603, \#5205, \#7252, \#5861, \#6772, …).

_libs/code/deepagents\code/client/launch · medium confidence · unverified

Deep Agents SDK v0.7.21: New public API surface and internal refactoring

The deepagents package now exposes a consolidated public API via its main \_\init\\_.py, making core components like DeepAgentState, create\_deep\_agent, and various middleware (AsyncSubAgentMiddleware, FilesystemMiddleware, MemoryMiddleware, RubricMiddleware, SubAgentMiddleware) directly importable from the top-level package. This release also introduces internal infrastructure for better deprecation management (centralized langchain\_core deprecation adapters with correct stack-level attribution), refined model resolution helpers that properly normalize provider names and handle Bedrock/Nova identifiers, and a new \_excluded\_middleware module that allows users to selectively disable specific middleware via HarnessProfile configurations. The package version has been updated to 0.7.21, and type checking support is now explicitly marked with py.typed.

libs/deepagents/deepagents · high confidence

Introduce Hooks v2 with legacy migration and security hardening

The hooks subsystem has been replaced by Hooks v2, which uses typed Pydantic models for configuration and wire payloads, and a new interrupt/resume transport for server-owned events. To ensure continuity, legacy \hooks.json\ entries are automatically migrated to the new v2 schema at load time, while the legacy dispatcher remains available for backward compatibility until September 1, 2026. Security is improved by sanitizing subprocess environments to strip secret-like variables and by validating terminal escape sequences in hook output. The system also attaches session identity and server event gates to the graph context and routes tool-use failures to a dedicated failure event.

_libs/code/deepagents\code/hooks · high confidence

Introduces provider profiles for OpenAI, OpenRouter, and NVIDIA

The SDK now includes a built-in provider profile system that automatically configures specific LLM providers. OpenAI models now use the Responses API by default. OpenRouter requests include app attribution headers and, by default, ignore Azure as an upstream provider to prevent multi-turn reasoning failures (configurable via the DEEPAGENTS\_OPENROUTER\_ALLOW\_AZURE environment variable). NVIDIA NIM requests include app-origin attribution headers.

libs/deepagents/deepagents/profiles/provider · high confidence

Test coverage

Added benchmark tests for CLI startup and session loading performance; Added benchmarks for deep agent construction and summarization middleware; Added comprehensive test suite for Talon core components; Added integration test suite for deepagents-code; Added integration tests for QuickJS PTC and subagent middleware; Added integration tests for Talon runtime and channel adapters; Added integration tests for deepagents SDK components; Added smoke tests for QuickJS system prompt stability; Added smoke tests for system prompt snapshots; Added snapshot test for CLI agent system prompt; Added test coverage for Talon channel adapters; Added test infrastructure and utilities for the Deep Agents SDK; Added test suite for ACP agent server and utilities; Added test suite for Daytona sandbox integration; Added test suite for the Modal partner integration; Added tests for WhatsApp bridge ID compatibility and media handling; Added tests for per-user memory isolation in the content writer example; Added tests for the Talon cron scheduling system; Added unit and integration tests for the Runloop partner package; Added unit tests and benchmarks for QuickJS REPL middleware; Added unit tests for Hooks v2 system; Added unit tests for TUI modal interactions; Added unit tests for Talon runtime components; Added unit tests for deepagents backends; Added unit tests for deepagents core components; Added unit tests for deepagents middleware components; Added unit tests for skills CLI, loading, trust, and thread inspector; Added unit tests for the plugin manager modal; Added unit tests for tools module; Expanded unit test coverage for CLI commands and core agent logic; Unit tests for plugin marketplace and installation logic.

Dependencies

Update dependency minimums and add security overrides across Deep Agents ecosystem

This release updates the minimum version requirements for core and partner packages (including \deepagents\, \langchain\, \langchain-anthropic\, \langchain-google-genai\, \langgraph\, and \langsmith\) across the SDK, examples, and partner integrations. It also adds explicit security overrides for \nbconvert\ and \protobuf\ in the deep research example to address [CVE redacted] and [CVE redacted], and raises the minimum Python version to 3.12 for the better-harness example.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 59 → 63 (+4.6)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 82 → 83 (+0.5)
  • Architecture 92 → 93 (+1.3)
  • Maturity 56 → 79 (+23.3)
  • Readiness 46 → 46 (+0.1)
  • Security 81 → 74 (-6.3)
  • Performance 87 → 87 (+0.0)

Resolved (312)

  • AutoModeHITLMiddleware._human_review (cognitive 31) (libs/code/deepagents_code/auto_mode.py)
  • AutoModeHITLMiddleware._human_review (cyclomatic 23) (libs/code/deepagents_code/auto_mode.py)
  • AutoModeHITLMiddleware._validated_plan (cognitive 36) (libs/code/deepagents_code/auto_mode.py)
  • AutoModeHITLMiddleware._validated_plan (cyclomatic 35) (libs/code/deepagents_code/auto_mode.py)
  • AutoModeHITLMiddleware.aafter_model (cognitive 60) (libs/code/deepagents_code/auto_mode.py)
  • AutoModeHITLMiddleware.aafter_model (cyclomatic 47) (libs/code/deepagents_code/auto_mode.py)
  • AutoModeHITLMiddleware.awrap_model_call (cognitive 68) (libs/code/deepagents_code/auto_mode.py)
  • AutoModeHITLMiddleware.awrap_model_call (cyclomatic 48) (libs/code/deepagents_code/auto_mode.py)
  • CLICompactionMiddleware._summarization_for_runtime (cognitive 23) (libs/code/deepagents_code/offload_middleware.py)
  • CLICompactionMiddleware._summarization_for_runtime (cyclomatic 17) (libs/code/deepagents_code/offload_middleware.py)
  • ConfigOption.__post_init__ (cognitive 22) (libs/code/deepagents_code/config_manifest.py)
  • ConfigOption.__post_init__ (cyclomatic 22) (libs/code/deepagents_code/config_manifest.py)
  • Credentials._reload_values (cognitive 30) (libs/code/deepagents_code/config.py)
  • Credentials._reload_values (cyclomatic 22) (libs/code/deepagents_code/config.py)
  • DeepAgentsApp._prune_messages_unlocked (cognitive 31) (libs/code/deepagents_code/app.py)
  • DeepAgentsApp._prune_messages_unlocked (cyclomatic 17) (libs/code/deepagents_code/app.py)
  • DiffMessage.compose (cognitive 18) (libs/code/deepagents_code/tui/widgets/messages.py)
  • Duplicate intent with inconsistent return types and naming. read_git_branch_from_filesystem and read_git_branch_via_subprocess perform the same logical operation (reading the current git branch) but use different mechanisms. The naming from_filesystem vs via_subprocess exposes implementation details rather than intent. Furthermore, their return types differ: the filesystem version returns str | None (allowing for 'no branch' state), while the subprocess version returns str (likely raising an exception or returning a default on failure). This inconsistency forces callers to handle different error states for the same logical outcome.
  • Duplicated block (10 lines × 2) (libs/code/deepagents_code/main.py)
  • Duplicated block (10 lines × 6) (libs/code/deepagents_code/config.py)
  • …and 292 more

New (56)

  • DaytonaSandbox._wait_for_exit (cognitive 18) (libs/partners/daytona/langchain_daytona/sandbox.py)
  • DeepAgentRuntime._invoke_payload_with_retries (cognitive 16) (libs/talon/deepagents_talon/runtime.py)
  • DeepAgentsApp._handle_trace_command (cyclomatic 16) (libs/code/deepagents_code/app.py)
  • DeepAgentsApp._handle_update_action (cyclomatic 18) (libs/code/deepagents_code/app.py)
  • DeepAgentsApp._refresh_dependencies_unlocked (cognitive 16) (libs/code/deepagents_code/app.py)
  • DeepAgentsApp._regroup_completed_tools (cyclomatic 16) (libs/code/deepagents_code/app.py)
  • DeepAgentsApp._set_approval_mode (cognitive 16) (libs/code/deepagents_code/app.py)
  • DeepAgentsApp.on_deep_agents_app_server_start_failed (cyclomatic 16) (libs/code/deepagents_code/app.py)
  • Duplicated block (10 lines × 2) (libs/code/deepagents_code/cost_tracking.py)
  • Duplicated block (10 lines × 2) (libs/deepagents/deepagents/middleware/async_subagents.py)
  • Duplicated block (10–12 lines × 2) (libs/code/deepagents_code/client/commands/extras.py)
  • Duplicated block (12–13 lines × 2) (libs/deepagents/deepagents/middleware/async_subagents.py)
  • Duplicated block (13–24 lines × 2) (libs/code/deepagents_code/plugins/commands_cli.py)
  • Duplicated block (21–24 lines × 2) (libs/code/deepagents_code/app.py)
  • Duplicated block (5 lines × 2) (libs/deepagents/deepagents/middleware/async_subagents.py)
  • Duplicated block (7–8 lines × 2) (libs/code/deepagents_code/model_api.py)
  • Edited copy of a member (32 corresponding lines) (libs/code/deepagents_code/client/launch/server_manager.py)
  • FileTooLong: checks/raise_langchain_minimums.py (.github/scripts/checks/raise_langchain_minimums.py)
  • FileTooLong: plugins/discovery.py (libs/code/deepagents_code/plugins/discovery.py)
  • High CVE: [GHSA redacted] (libs/talon/deepagents_talon/channels/whatsapp_bridge/package-lock.json)
  • …and 36 more

Changes since last survey

  • 300 commits — 238 feature/other, 62 fixes

By area

  • libs/code — 126 commits
  • libs/partners — 43 commits
  • libs/talon — 23 commits
  • libs/deepagents — 17 commits
  • libs/evals — 14 commits
  • openwiki/.claims — 13 commits
  • examples/deep_research — 12 commits
  • .github/scripts — 10 commits
  • examples/nvidia_deep_agent — 8 commits
  • .github/workflows — 7 commits
  • (root) — 5 commits
  • examples/content-builder-agent — 5 commits
  • examples/text-to-sql-agent — 5 commits
  • .github/RELEASING.md — 3 commits
  • .github/actions — 2 commits
  • examples/async-subagent-server — 2 commits
  • libs/acp — 2 commits
  • .github/ISSUE_TEMPLATE — 1 commit
  • examples/llm-wiki — 1 commit
  • openwiki/.last-update.json — 1 commit

Notable commits

  • fix: chore(deps): bump pillow to 13.0.0 for security fixes (#7125)
  • fix: chore(infra): ask how bug reports were discovered (#7409)
  • fix: fix(ci): parse the wrapped squash-merge message in the release-please check (#7297)
  • fix: fix(ci): retry release-note drafting when the head changes (#7326)
  • fix: fix(ci): stop recording labeler runs as deployments (#7126)
  • fix: fix(code): allowlist Git options in Auto mode's read-only fast path (#7276)
  • fix: fix(code): auto-migrate to Python 3.14 when no other session is running (#7160)
  • fix: fix(code): block auto mode when its classifier cannot resolve (#7346)
  • fix: fix(code): bridge upgrades to Python 3.14 (#7081)
  • fix: fix(code): clarify MCP configuration refresh in /reload (#7497)
  • fix: fix(code): clarify Python update instructions (#7343)
  • fix: fix(code): clarify credential setup recovery (#7347)
  • fix: fix(code): collapse ChatGPT sign-in browser URL by default (#7348)
  • fix: fix(code): confirm auto-update success only after loading new version (#7344)
  • fix: fix(code): contain JavaScript subagent failures (#7211)
  • fix: fix(code): correct transcript height hints for folded tool rows (#7251)
  • fix: fix(code): decode git output as UTF-8 (#7142)
  • fix: fix(code): defer in-app uv installs on Windows (#7518)
  • fix: fix(code): delay tool group progress to avoid flashing (#7357)
  • fix: fix(code): disclose inherited classifier model switches (#7351)
  • …and 280 more

Architecture

  • Unchanged — 0 containers · 7 contexts · 0 edges

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

langchain-ai/deepagents was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 4 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit c4e2811312718e98b1465b6e67c34997ca72c793 — the exact code this score is about.
  • Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
  • Measured by watchdog.canine.dev using codehealth-analyzer measure-2026.11.2+preprod-f7b8aaa3a438.