langchain-ai/deepagents

Features

• Agent Communication Protocols - Ensures interoperability by implementing Model Context Protocol and Agent-to-Agent standards.
• Agent Orchestration Platforms - Provides a comprehensive platform for deploying and managing stateful AI agents with versioning and multi-agent delegation.
• AI Agent Infrastructure - Provides a containerized runtime and cloud environment for hosting AI graphs with integrated secrets and scaling.
• Containerized Deployment Runtimes - Wraps agent graphs and dependencies into Docker images for consistent scaling and cloud orchestration.
• Stateful Agent Hosting - Provides a stateful runtime that manages the execution and persistence of agent graphs.
• Long-term Memory Stores - Provides REST endpoints to control assistant threads, execution runs, and long-term memory stores.
• Run History Deletions - Allows the removal of specific agent invocations from a thread's historical record using unique identifiers.
• Recurring Agent Scheduling - Allows triggering autonomous agent tasks based on fixed intervals or cron-like schedules.
• Agent Delegation - Supports assigning complex jobs to specialized sub-agents with isolated context windows.
• Agent Deployment Runtimes - Enables the deployment of configured computational graphs to serve as persistent AI agents for users.
• Agent Evaluation Tools - Provides specialized testing suites to assess the reasoning, tool usage, and conversational flow of AI agents.
• Agent Execution Tracing - Automatically captures agent invocations, tool calls, and LLM interactions for debugging and reasoning inspection.
• Agent Memory Persistence - Maintains long-term state and session continuity by saving key-value data in a persistent store.
• Agent State Management - Invokes assistants on threads to update state or perform one-off stateless executions.
• Agent State Persistence - Persists graph state using configurable backends to maintain continuity across agent executions.
• Blueprints - Provides a blueprinting system to rapidly instantiate complex multi-agent workflows and chatbots.
• Agentic Context Management - Implements systems for managing memory and knowledge scopes to prevent LLM context window overflow.
• Agent Configuration Management - Manages agent defaults, credentials, and metadata through structured configuration files for consistent environment behavior.
• Stateful Workflow Persistence - Maintains persistent conversation memory and checkpoints to enable long-term recall and state continuity.
• Agent Configuration Tools - Provides tools to package system prompts, instructions, and tool links into deployable agent repositories.
• Agent Execution Runtimes - Provides a runtime for calling deployed AI agents via client libraries to execute tasks.
• Agent Configuration Schemas - Uses standardized schemas to define agent behavior, personas, and tool availability without hard-coded logic.
• Model Context Protocol - Exposes agent tools and capabilities to external clients via the standardized Model Context Protocol.
• AI Application Orchestrators - Orchestrates the build and deployment of Docker images to Kubernetes clusters for AI-powered applications.
• Conversation State Managers - Tracks accumulated outputs and state of agent runs to maintain continuity across interactions.
• External Tool Integration - Connects agents to custom functions and protocol servers to extend their operational capabilities.
• Conversation Threads - Initializes persistent sessions to store accumulated outputs and state for agent runs.
• MCP Servers - Provides endpoints that implement the Model Context Protocol, allowing agents to act as servers.
• Memory Persistence - Uses pluggable state and store backends to recall information and maintain continuity across user sessions.
• Model Context Protocol Servers - Implements a server that exposes agent tools and capabilities using the Model Context Protocol.
• Stateful Run Executions - Executes agent invocations within specific threads to maintain and update conversation state across multiple steps.
• Stateful LLM Application Servers - Manages conversation threads, checkpoints, and long-term memory to support complex, multi-turn LLM interactions.
• Agent Building Platforms - Offers a no-code management interface for building and deploying custom autonomous AI agents.
• LLM Observability and Evaluation - Captures execution traces and uses automated evaluators to analyze model performance and reasoning paths.
• Agent State Persistence - Stores application checkpoints and thread metadata to a local disk or database to ensure execution continuity.
• Conversation History Retrieval - Retrieves the history of agent invocations for a specific conversation thread with support for status filtering.
• Visibility Filtering - Limits the visibility of agents and threads during search operations using metadata filters.
• Persistent Storage Provisioning - Manages the provisioning of dedicated databases to serve as the persistence layer for agent deployments.
• Conversation Step Streaming - Provides real-time streaming of conversation updates as each sequential agent step executes.
• Session State Management - Stores session data in a checkpoint store so state survives restarts across thread turns.
• State Checkpointing - Saves agent graph snapshots to a pluggable backend to enable execution resumption and state rollback.
• Cron Scheduling - Enables running AI assistants on a recurring timetable using standard cron expressions.
• Execution State Monitoring - Returns the final state of a task upon completion and supports real-time output streaming.
• Background Task Runners - Triggers agent runs within a thread in the background and returns a run ID immediately.
• Cloud Agent Deployers - Automates the hosting of agent runtimes and databases on managed AWS and GCP infrastructure via CLI.
• Deployment Configuration - Uses configuration files to define agent graphs, environment variables, and dependencies for deployment.
• Deployment Automation - Implements automated workflows to deploy agents to preview and production environments via an API or UI.
• Agent Runtime Instantiations - Instantiates configured computational graphs into live execution environments to serve as agents.
• Execution Terminations - Implements immediate termination of running agent invocations and state rollback via checkpoint deletion.
• JSON-RPC Interfaces - Uses JSON-RPC standardized messaging to enable communication between agents and Model Context Protocol servers.
• Real-time Event Streams - Ships real-time output streaming using server-sent events to minimize latency between generation and delivery.
• Token Streaming - Enables real-time delivery of LLM-generated tokens and tool execution progress to the user interface.
• Run Lifecycle Controls - Provides controls to stop active agent executions based on thread IDs, run IDs, or current status.
• Bulk Cancellations - Enables the simultaneous termination of multiple agent tasks using run IDs or status filters.
• Attribute-Based Access Control - Enforces permissions based on resource metadata and tags to grant fine-grained access.
• Authentication Service Integrations - Integrates external authentication logic and defines security schemes for API requests.
• Encrypted Secret Management - Provides secure storage and injection of encrypted secrets for agent authentication with external services.
• Resource-Level Access Controls - Validates permissions against specific resource instances, such as conversation threads and assistants.
• API Request Authentication - Verifies the identity of callers by validating API keys provided in request headers.
• OAuth Authentication - Implements standard OAuth 2.0 flows to exchange authorization codes for access tokens.
• OAuth Providers - Configures external OAuth providers to secure access to third-party systems.
• Repository Visibility Controls - Controls access to agent and skill repositories using workspace-specific visibility settings.
• Role-Based Access Control - Manages user permissions and access levels across workspaces using role-based and attribute-based controls.
• Workspace Isolation - Implements trust boundaries and access control to isolate users and resources within separate workspaces.
• Credential Delegation - Passes authenticated user credentials into the agent context to execute operations on the user's behalf.
• User Authentication Systems - Provides mechanisms for verifying user identity and associating executions with specific end-users via custom handlers.
• Asynchronous Task Orchestration - Manages background agent executions using a polling and event-based system for long-running tasks.
• Command Scoping - Allows sending scoped requests to specific threads to trigger background actions based on context.
• Asynchronous Task Execution - Executes agent tasks asynchronously on specific threads with support for status polling and result retrieval.
• Behavioral Customization Schemas - Enables customization of model selection, prompts, and tools using structured schemas without changing code.
• Stateless Execution - Triggers one-off agent tasks in the background that bypass state persistence for lower latency.
• Agent Execution Tracing - Records graph states and LLM prompts to a specialized observability platform for analyzing agent reasoning.
• Agent Management Planes - Implements a centralized control plane for deploying, scaling, and overseeing AI agent operations and human-review loops.
• Run Metadata Retrieval - Fetches the status, metadata, and configuration of specific agent invocations associated with conversation threads.
• LLM Performance Monitoring - Captures traces, latency, and token usage for LLM agents deployed on cloud infrastructure.
• LLM Evaluation - Uses language models as automated judges to evaluate the quality and consistency of agent reasoning.
• Evaluation Feedback Aligners - Aligns automated judge judgments with human assessments by inserting corrected scores as few-shot examples.
• Agent-to-Agent Communication - Facilitates direct interaction and data exchange between multiple agents via standardized protocols.
• Agent Deployment Servers - Supports running the agent server independently of a central control plane using Docker or Kubernetes.
• Agent Framework Integrations - Integrates agents built with third-party frameworks into a unified production environment.
• Agent Integration APIs - Provides dedicated SDKs and REST APIs for programmatic interaction with deployed agents.
• Agent Observability Tools - Captures execution traces and evaluates agent performance through specialized monitoring and metrics.
• Agent Provider Integrations - Provides interfaces for managing secure connections and credential verification for external AI model providers.
• Skill Repository Linking - Connects agents to shared skill repositories so that capability updates propagate automatically to all parent agents.
• Repository Management - Enables automated workflow integration through programmatic control of agent and skill repositories.
• Assistant Metadata - Enables recursive retrieval of schema metadata for assistant subgraphs.
• Skill Packaging - Bundles agent instructions, templates, and schemas into versioned repositories that agents can invoke.
• Assistant Management - Includes tools for searching and filtering available assistants based on specific criteria.
• Assistant Lifecycle Management - Facilitates the retrieval of an assistant's structural representation, including nested subgraphs.
• Container Dependency Configuration - Allows users to add custom system packages and Python dependencies to the agent's container via configuration.
• Dynamic Configuration Updates - Allows modifying agent configurations, metadata, and associated graphs without recreating the agent.
• Concurrency Managers - Serializes agent runs to prevent race conditions and manage incoming messages while a request is processing.
• OpenAI-Compatible APIs - Supports connections to any model provider that implements the OpenAI API specification.
• Automated Output Evaluation - Checks application responses against saved assertions using an offline automated evaluator.
• Automated Skill Loading Systems - Allows agents to attach and load predefined behavioral skills on-demand for specific tasks.
• Deterministic Evaluators - Allows defining deterministic evaluation logic using Python or TypeScript to grade outputs without relying on LLMs.
• Trace-to-Dataset Converters - Converts captured production execution traces into dataset examples for automated model evaluation.
• Automated Dataset Evaluation - Runs defined evaluators against dataset examples to measure agent performance automatically.
• Acceptance Criteria Mapping - Captures requirements as dataset examples during run reviews to create automated acceptance checks.
• Custom Performance Metrics - Enables creation of custom functions to compare application outputs against dataset examples for performance calculation.
• Evaluation Report Aggregators - Combines multiple evaluator scores into a single comprehensive metric using weighted averages or sums.
• ML Model Server Integrations - Enables integration of external model APIs into testing environments for response generation and parameter tuning.
• Human Feedback Collection - Allows managing configurations that define how human feedback, such as scores and categories, is collected.
• Human-in-the-loop Controls - Requires human approval, editing, or rejection of tool calls before an agent can execute them.
• Thread Search Services - Provides APIs for querying and retrieving historical conversation threads based on specific search criteria.
• Model Comparison Interfaces - Provides side-by-side visual comparisons of outputs generated by different machine learning models.
• Evaluation Score Auditing - Provides a user interface or SDK to manually correct model-generated evaluation scores.
• Prompt Optimizers - Provides a conversational interface to refine prompts and create output schemas for better model behavior.
• Model Performance Evaluators - Compares experiment results against dataset examples to identify the most effective agent configurations.
• Prompt Design Strategies - Supports the construction of prompts using diverse message roles, system instructions, and few-shot examples.
• Prompt Management Systems - Provides a platform for versioning, deploying, and managing prompts for AI models.
• Structured Output Diffing - Highlights modifications between JSON or YAML outputs in a side-by-side visual diff view.
• Structured Output Enforcements - Enforces data models or schemas on agent outputs to ensure machine-readable formatting.
• Structured Output Parsers - Enables retrieval of typed values from agents using configured output schemas and keys.
• User Feedback Collection - Generates pre-signed URLs to link external user feedback directly to specific execution traces.
• Data Retention Policies - Provides mechanisms for managing the lifecycle and automatic deletion of persisted threads and memories.
• Expired Record Purging - Automatically deletes old conversation threads and associated checkpoints based on time-to-live settings.
• Orchestration Graph Visualizers - Provides a specialized environment to visualize and interact with AI orchestration graphs during development.
• Persistent State Management - Injects persistence, memory, and human-in-the-loop capabilities into existing agent logic.
• Pluggable Storage Drivers - Provides a modular architecture for registering custom storage backends for agent state and long-term memory.
• Experiment Run Grouping - Interprets run data using customizable columns and filtering by model, prompt, or tool.
• Repetition Analysis - Analyzes multiple iterations of the same experiment via summary tables of performance metrics.
• Review Workflows - Implements a focused workflow for human reviewers to provide feedback on grouped agent execution runs.
• Run Comparison Tools - Provides tools to evaluate performance differences between two experiments or against a designated baseline.
• Semantic Search - Enables vector-based retrieval by configuring embeddings for specific document fields within the memory store.
• User Behavior Analysis - Examines conversation threads to analyze user sentiment and verify problem resolution.
• Agent Graph Packaging - Provides a CLI to build and package agent graphs locally for seamless cloud deployment.
• CLI Agent Runners - Provides a command-line interface to build, deploy, and interact with AI agents locally.
• Local Development Servers - Ships a lightweight local development server with hot reloading and debugging for rapid testing.
• Deployment Revisions - Allows deploying new code changes as distinct revisions via manual updates or Git pushes.
• Sandboxed Execution Environments - Provides isolated computing environments to safely execute system shell commands for technical tasks.
• Application Updaters - Provides automated workflows for refreshing the agent environment with new container images and configurations.
• Agent Configurations - Tracks historical versions of agent configurations and prompts to enable rollbacks and environment promotion.
• Agent Versioning - Tracks and retrieves the history of configured versions for agent instances, including metadata and settings.
• Autoscaling Systems - Dynamically adjusts active container counts based on CPU, memory, or task volume.
• Docker Container Execution - Provides the ability to launch the API server locally using Docker containers and local databases.
• Docker Image Building - Creates Docker images for the API server based on defined configuration files.
• AI Model - Connects to external applications via verified authorization screens and identity terms through a model control plane.
• State Storage Implementations - Allows replacing the default database with a custom storage backend to persist agent state.
• Incremental State Persistence - Saves only state changes instead of full payloads to optimize performance for large histories.
• Deployment Management - Enables the programmatic creation and update of server deployments using GitHub, Docker, or templates.
• Deployment Lifecycle Controls - Provides governance over the rollout process, including control over agent versions and deployment states via API.
• Managed Cloud Deployments - Provides a managed pipeline to build container images and push them to registries for cloud deployment.
• Graph-Based Logic Deployment - Wraps custom code and external libraries within a graph structure for managed deployment.
• Deployment Orchestration - Automates the management of application deployment workflows to facilitate custom CI/CD orchestration.
• Deployment Scaling - Adjusts active replicas based on CPU and memory usage to maintain performance under load.
• Enterprise Hosting Platforms - Provides infrastructure resources to handle communication for secure, self-hosted enterprise organizations.
• Git Deployment Integrations - Connects to external Git repositories to retrieve source code for agent deployment.
• Infrastructure Scaling - Configures execution environments as either single host or distributed runtimes to match traffic needs.
• Private Infrastructure Hosting - Provides the ability to deploy the entire agent server and control plane on private infrastructure for data residency.
• Self-Hosted Deployment Platforms - Enables automated provisioning of the complete observability and agent platform on private infrastructure using Terraform.
• Annotation Queues - Provides a mechanism to build review queues using feedback schemas and scoring rubrics for human annotators.
• Distributed Trace Propagation - Propagates trace context via HTTP headers to group requests into a single unified distributed trace.
• Thread State History - Provides the ability to fetch past states for specific conversation threads using metadata filtering and checkpoint targeting.
• RPC Protocols - Implements JSON-RPC 2.0 for synchronous responses and event-driven streaming between agents.
• Credential Authentication - Uses middleware to verify user credentials and attach identity information to incoming requests.
• Data Encryption - Secures store values and API payloads using custom encryption middleware and user-defined methods.
• Encrypted Persistence - Protects sensitive application state and checkpoints using AES encryption at rest.
• External Identity Provider Integration - Establishes secure connections to external service providers using OAuth tokens and defined access scopes.
• Identity Verification Modules - Verifies identity tokens against external providers to authorize access to platform resources.
• User Identity Management - Manages user profiles and authentication via email, passwords, and external identity platforms.
• Agent Graph Configurations - Provides retrieval of agent graph configurations, including structural definitions and environment variables.
• Asynchronous Task Managers - Manages background agent runs with support for real-time streaming and task cancellation.
• Persistence Metadata Updates - Allows modification of thread metadata and time-to-live settings to control the persistence of agent state.
• Stateful Execution Resumption - Restores agents to previous states to debug failures or explore alternative reasoning paths.
• Stateless Response Streaming - Provides incremental output for stateless agent invocations using Server-Sent Events.
• Execution Pausing - Allows users to halt workflow progress at designated nodes for manual inspection and debugging.
• Workflow Execution Event Streams - Streams real-time event data from active agent runs with support for resuming from specific event IDs.
• Graph Application Runtimes - Enables programmatic interaction with remote agents using SDKs or a simulated local runtime.
• Webhook Event Notifications - Sends automated notifications to external systems when specific agent run events are triggered.
• Event History Replayers - Includes event history replayers that allow clients to resume from a specific sequence number after reconnection.
• Multi-tenant Isolation Policies - Implements mechanisms for enforcing data boundaries and granular access control across organizational workspaces.
• Deployment - Monitors the control plane for desired state changes and automatically updates deployments to match.
• Synchronous Execution Models - Implements synchronous execution models where the client connection remains open until the agent produces a final output.
• Agent Observability - Allows visualization of specific agent decisions at particular nodes through filtered data series.
• State Visualization - Offers a graphical interface connected to a local server to visually debug agent internal states.
• Experiment Result Comparators - Identifies regressions and improvements across model iterations by contrasting performance metrics.
• System Quality Evaluators - Implements frameworks to measure output quality by running target functions against datasets of test inputs.
• Checkpoint State Extraction - Enables retrieval of conversation thread states at specific checkpoints, including associated subgraph data.
• Execution Tracing - Records function calls and nested execution paths as traces to debug complex agent logic.
• Trace Annotation - Allows attaching feedback tags, scores, and comments to specific steps within an execution trace.
• Distributed Tracing and Execution Analysis - Enables querying of execution data using natural language to identify failure patterns and trajectories.
• Distributed Tracing - Unifies execution logs across different services to track a single request across distributed architectures.
• Metric and Performance Monitors - Provides a visual dashboard for monitoring the health and performance metrics of live agent deployments.
• Evaluation Metric Monitors - Tracks LLM-specific metrics such as run counts, costs, and error rates to trigger operational alerts.
• Application Health Monitors - Visualizes deployment health through charts tracking API latency and error rates.
• Trace Data Redaction - Hides specific inputs and outputs of recorded runs to protect sensitive data while preserving trace structure.
• Trace Feedback Mechanisms - Logs evaluations and qualitative assessments against specific execution steps or root traces.
• Token Cost Calculators - Calculates financial costs of LLM calls by applying pricing to recorded token usage.
• Graph Logic Validation - Offers a local server with a visual interface to debug agent graph logic and configurations.
• Third-Party API Integrations - Integrates agents with third-party services like Gmail and Slack using OAuth and app authorizations.
• Agent Frameworks - Agent harness for planning, task decomposition, and long-term memory management.
• Agent Harnesses - Opinionated harness framework for building deep reasoning agents.
• AI Agents and Automation - LangChain framework for building sophisticated multi-agent systems.

Star history