deer-flow

Implements a lead agent pattern using LangGraph's state machine architecture to coordinate multi-step task execution across a distributed agent network. The lead agent maintains a shared state graph that tracks task decomposition, subtask delegation, and result aggregation, with middleware pipeline hooks for pre/post-processing at each graph node. This enables long-horizon task planning where agents can reason about dependencies and execute tasks in parallel or sequential order based on dynamic conditions.

Implements a hierarchical agent system where the lead agent can spawn child subagents to handle specific task domains, with each subagent capable of spawning further subagents recursively. The subagent executor manages a task queue with configurable parallelism limits, tracks parent-child relationships in thread state, and aggregates results back to the parent context. Each subagent inherits a scoped view of memory, tools, and skills from its parent, enabling domain-specific specialization while maintaining context continuity.

Provides a declarative configuration system using YAML files for model selection, tool definitions, skill loading, memory settings, sandbox backends, and channel configurations. The configuration loader supports environment variable overrides, hierarchical config merging (base config + environment-specific overrides), and validation against a schema. Enables deployment flexibility without code changes — same codebase can run with different models, tools, and backends by changing configuration.

Implements an HTTP API gateway that routes requests to the LangGraph agent server, manages request/response serialization, and supports streaming responses via Server-Sent Events (SSE) or chunked transfer encoding. The gateway handles authentication (API keys, JWT), rate limiting, request validation, and error responses with appropriate HTTP status codes. Provides REST endpoints for chat, thread management, artifact retrieval, and configuration queries.

Implements a composable middleware system that intercepts agent execution at key points (before LLM call, after tool execution, before response to user) and applies transformations or validations. Middleware can be chained in sequence, with each middleware receiving the execution context and able to modify state, inject additional context, or short-circuit execution. Enables cross-cutting concerns like logging, monitoring, content filtering, and context enrichment without modifying agent code.

Integrates web search capabilities (via search APIs or MCP servers) as agent tools, enabling agents to query the internet for current information, research topics, and fact-checking. The search integration supports multiple search backends (Google, Bing, DuckDuckGo), result filtering and ranking, and caching of search results to reduce API calls. Agents can use search results to augment their knowledge and provide up-to-date information in responses.

Provides isolated execution environments for arbitrary code (Python, bash, etc.) using pluggable sandbox backends (Docker, Kubernetes, local process isolation). The sandbox system implements path virtualization to prevent directory traversal attacks, manages resource limits (CPU, memory, timeout), and provides a tool interface for agents to execute code without direct system access. Supports multiple concurrent sandbox instances with automatic cleanup and configurable backend selection per deployment environment.

Maintains a long-term memory store that persists facts extracted from conversations with confidence scores indicating reliability. The memory system uses an LLM-based extraction pipeline to identify and store facts from agent outputs, implements a summarization mechanism to compress old memories when reaching capacity limits, and provides a retrieval interface for agents to query relevant facts during task execution. Memory is scoped per conversation thread and can be selectively cleared or updated based on confidence thresholds.

Provides a plugin architecture for loading specialized workflows as .skill archives (compressed bundles containing prompts, tools, and configuration). Skills are loaded dynamically at runtime and composed into the agent's capability set, with each skill defining its own system prompts, tool bindings, and execution hooks. The skills system enables domain-specific agent specialization without modifying core agent code, supporting skill versioning and conditional loading based on task requirements.

Implements a unified tool registry that supports both native Python tools and Model Context Protocol (MCP) servers, enabling agents to call functions with schema-based validation. The tool system generates OpenAI/Anthropic-compatible function calling schemas from tool definitions, manages tool execution with error handling and retry logic, and supports streaming responses for long-running tools. Tools can be conditionally loaded based on agent capabilities and task context.

Provides a message gateway abstraction that enables deployment across multiple communication channels (Slack, Discord, Telegram, etc.) without modifying agent code. The IM channels architecture translates between channel-specific message formats and a unified internal message protocol, manages channel-specific state (user sessions, thread contexts), and handles authentication/authorization per channel. Supports streaming responses and rich message formatting (buttons, embeds) with graceful degradation for channels with limited capabilities.

Implements a safety layer that validates agent outputs against configurable guardrails before sending to users, including content filtering (blocking harmful content), alignment checks (ensuring outputs match system values), and rate limiting. The guardrails system uses both rule-based filters and LLM-based semantic validation, supports custom guardrail definitions, and logs all filtered content for audit purposes. Guardrails can be applied at multiple stages (tool execution, agent output, user response).

Manages conversation state per thread (conversation ID), tracking message history, subtask execution, generated artifacts (code, documents, etc.), and intermediate results. The state management system persists thread state to a backend store, enables resuming interrupted conversations, and provides a unified view of all artifacts generated during a conversation. Supports thread forking (creating branches from a conversation point) and merging results from parallel subtasks back into the main thread state.

Provides a React-based web UI with real-time message streaming, progressive rendering of agent outputs, and rich message formatting (code blocks, tables, markdown). The frontend implements a message rendering system that handles different message types (text, code, artifacts, suggestions), displays subtask execution progress, and provides controls for thread management (fork, branch, resume). Uses WebSocket connections for streaming responses and maintains local state for optimistic UI updates.