Skip to content
CAI
Software that uses CAICheck a score

bytedance/deer-flow

46.3

Weak · 14 November 2026

359.2k

lines of production code

Python

with TypeScript

6

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add BoxLite micro-VM sandbox provider

DeerFlow now supports running sandboxes as BoxLite micro-VMs (daemonless, OCI-native VMs with their own kernel) via the optional \deerflow-harness\[boxlite\]\ extra. This provider offers a hardware-isolated alternative to the default Docker sandbox, reducing resource overhead and cold-start latency. Users can enable it by setting \sandbox.use\ to \deerflow.community.boxlite:BoxliteProvider\ in their configuration, with optional tuning for memory, vCPUs, warm-pool replicas, and idle timeouts. Note that this provider requires a Linux host with KVM or a macOS host with Hypervisor.framework. Also in this area: 5 commits (1 fix) modifying backend/packages/harness; 2 commits (2 fixes) fixing backend/packages/harness/deerflow/community; Fix Docker signal handling and document IM channel leadership leases; Fixes for DingTalk table rendering, WeChat config validation, and Feishu proactive notifications.

backend/packages/harness/deerflow/community/boxlite · medium confidence · unverified

Add Brave Search web and image tools

Users can now use the official Brave Search API for web and image searches via new community tools. This replaces the previous DuckDuckGo scraping method with a structured, authenticated API that provides an SLA and supports native recency filters. The implementation includes robust validation to handle malformed API responses and contains SSRF risks by validating URLs and IP addresses. Also in this area: 14 commits (11 fixes) fixing backend; IM channel shutdown and streaming fixes.

backend/packages/harness/deerflow/community/brave · medium confidence · unverified

Add Chinese documentation for the DeerFlow application

Adds the complete Chinese (zh) documentation set for the DeerFlow application, including the application overview, quick start, deployment guide, configuration, workspace usage, agent and thread management, and operations and troubleshooting. The entry also includes Chinese reference documentation for model provider integration, specifically covering the Volcano Ark (Ark) model service.

frontend/src/content/zh/application · high confidence

Add DeerMem scope-isolation benchmark

A new reproducible benchmark has been added to validate DeerMem's long-term memory safety boundaries. It measures two key aspects: semantic model quality (ensuring durable user facts are admitted while rejecting project/thread constraints and temporary instructions) and deterministic identity routing (ensuring writes reach only the correct user/agent bucket). The tool supports offline runs with deterministic fixtures and explicit live runs against configured LLM providers, producing metrics such as durable retention rate, unsafe persistence rate, and cross-agent/user contamination rates.

_backend/scripts/benchmark/deermem\_scope\isolation · high confidence

Add DuckDuckGo web search tool with robust error handling and region support

Users can now search the web using DuckDuckGo via the new \web\_search\ tool. This implementation distinguishes between genuine empty results and execution failures (such as rate limits, timeouts, or missing dependencies), ensuring that system errors are reported clearly rather than being silently treated as 'no results found'. It also includes logic to automatically infer and apply the correct Wikipedia region based on the query's language characters, and supports native time-range filtering for recent results.

_backend/packages/harness/deerflow/community/ddg\search · high confidence

Add English documentation for DeerFlow App

Adds a new English documentation section for the DeerFlow App, including an overview, quick start, deployment guide, configuration, workspace usage, agents and threads, and operations and troubleshooting pages. This provides users with comprehensive guidance on setting up, configuring, and operating the DeerFlow App.

frontend/src/content/en/application · high confidence

Add English introduction documentation for DeerFlow

Added a new set of English documentation pages under the introduction section, including 'Why DeerFlow', 'Core Concepts', and 'Harness vs App'. These pages explain DeerFlow's architecture as a runtime harness for long-horizon agents, detailing key concepts such as skills, sandboxed execution, subagents, and memory, and clarifying the distinction between the DeerFlow Harness (SDK/runtime) and the DeerFlow App (reference implementation).

frontend/src/content/en/introduction · high confidence

Add English tutorials for DeerFlow usage and deployment

New documentation pages have been added to the English tutorials section, covering the first conversation, creating a programmatic harness, using tools and skills, working with memory, and deploying DeerFlow via Docker Compose. These pages provide step-by-step guides and configuration examples for core user workflows.

frontend/src/content/en/tutorials · high confidence

Add Exa as a community search and fetch tool provider

Users can now use the Exa API for web search and content fetching via the new \web\_search\ and \web\_fetch\ tools. The implementation supports configuring a custom Exa-compatible base URL (via \base\_url\ config or \EXA\_BASE\_URL\ env var) and allows tuning result limits and content character counts, with robust validation to ensure numeric inputs are correctly coerced and URLs are safe.

backend/packages/harness/deerflow/community/exa · high confidence

Add Jsonify dataset rows tool

A new tool for processing dataset rows has been added to the community harness, enabling users to utilize the Jsonify functionality within their workflows.

backend/packages/harness/deerflow/community/jsonify · medium confidence

Add Lark integration support with credential switching

The frontend now includes a new Lark integration module that enables users to install, configure, and authenticate with Lark (and Feishu) applications. This change introduces the necessary API client functions and React Query hooks to manage the integration lifecycle, including checking status, initiating authorization flows, and completing configuration. A key capability added is the ability to switch Lark app credentials, allowing users to update their app\_id and app\_secret via a dedicated configuration endpoint.

frontend/src/core/integrations · high confidence

Add OpenSandbox community provider for DeerFlow sandboxes

DeerFlow now supports running sandboxes on OpenSandbox via a new community provider. Users can enable this by installing the optional \opensandbox\ SDK (\pip install 'deerflow-harness\[opensandbox\]'\) and configuring \sandbox.use\ to \deerflow.community.opensandbox:OpenSandboxProvider\ in their YAML config. The provider manages remote sandbox lifecycles, including warm-pool reuse, timeout renewal, and environment variable resolution, while implementing the full DeerFlow sandbox contract (command execution, file operations, and search/grep) through the OpenSandbox Python SDK. Also in this area: 5 commits (1 fix) modifying backend/packages/harness; Fixes for DingTalk table rendering, WeChat config validation, and Feishu proactive notifications; You.com web search provider added; sandbox env resolution and credential redaction fixed.

backend/packages/harness/deerflow/community/opensandbox · medium confidence · unverified

Add React Query and Next.js theme providers

The frontend now includes dedicated provider components to manage application state and theming. A new QueryClientProvider wraps the app with TanStack React Query for data fetching, while a ThemeProvider integrates next-themes to automatically enforce a dark theme on the root landing page (/) and use the system default elsewhere.

frontend/src/components · high confidence

Add SearXNG web search tool with pagination and safety controls

A new SearXNG-based web search tool is now available in the community tools. The implementation handles multi-page result collection by walking the SearXNG pagination API (up to 5 pages) to honor \max\_results\ settings larger than a single page. It includes robust error handling for malformed responses (such as HTML error pages returned as HTTP 200) and validates configuration inputs, falling back to defaults if \max\_results\ is unparseable. URLs are also sanitized via a safety filter before being returned to the agent.

backend/packages/harness/deerflow/community/searxng · high confidence

Add Serply web search tool

Users can now search the web using the Serply API by setting the SERPLY\_API\_KEY environment variable or configuring it in config.yaml. The tool supports three verticals—regular search, news, and scholar—allowing research runs to target recent coverage or academic papers. It includes robust input validation, such as handling invalid max\_results values and cleaning HTML from news summaries, and ensures URL safety by screening results through the common URL safety filter.

backend/packages/harness/deerflow/community/serply · high confidence

Add Sofya web search and fetch tools

Users can now use the Sofya hosted API for web search and page fetching. The new \web\_search\ tool returns result content (not just snippets) and supports configurable result counts, search depth, and time ranges, while the \web\_fetch\ tool retrieves a single page as clean markdown. Both tools require a Sofya API key (via environment variable or config) and include robust input coercion and error handling for malformed responses.

backend/packages/harness/deerflow/community/sofya · high confidence

Add Sofya web search and fetch tools

Users can now use the Sofya hosted API for web search and page fetching. The new \web\_search\ tool returns result content (not just snippets) and supports configurable result counts, search depth, and time ranges, while the \web\_fetch\ tool retrieves a single page as clean markdown. Both tools require a Sofya API key (via environment variable or config) and include robust input coercion and error handling for malformed responses. Also in this area: 5 commits (1 fix) modifying backend/packages/harness.

backend/packages/harness/deerflow/community/groundroute · medium confidence · unverified

Add Tencent Cloud WSA web search provider

Users can now use Tencent Cloud Web Search API (WSA) as a community search provider. The new tool handles API key configuration via environment variables or config, coerces max\_results settings with safe fallbacks for invalid inputs, and validates response structures to report format errors when page objects are missing or malformed.

_backend/packages/harness/deerflow/community/tencent\wsa · high confidence

Add Tenki cloud sandbox provider

DeerFlow now supports running sandboxes as isolated microVMs on Tenki cloud, offering a cloud-hosted alternative to the container-based AIO sandbox and the local-virtualization BoxLite backend. This new provider implements the full Sandbox contract, using Tenki's native filesystem API for file operations and shelling out to standard tools for directory and content search. It includes a warm-pool lifecycle for efficient reuse, deterministic sandbox naming, and configuration options for resource limits, idle timeouts, and host pinning.

backend/packages/harness/deerflow/community/tenki · high confidence

Add Unbrowse web fetch provider

Introduces a new \web\_fetch\ tool powered by the Unbrowse hosted service, allowing agents to retrieve web page content as markdown via a single JSON-RPC call. The implementation handles API key configuration, supports automatic or manual JavaScript rendering, and includes logic to surface HTTP errors from target pages along with the final resolved URL.

backend/packages/harness/deerflow/community/unbrowse · high confidence

Add Webz.io News Search provider

Users can now search recent news articles using the Webz.io provider via the web\_search tool. This integration supports filtering by time range, publication dates, language, country, source, sentiment, and category, and automatically sanitizes result URLs for safety. Also in this area: 14 commits (11 fixes) fixing backend.

backend/packages/harness/deerflow/community/webz · medium confidence · unverified

Add You.com web search provider

Users can now search the web using the You.com provider. This new tool integrates with You.com's Search API, automatically falling back to a free keyless endpoint when no API key is configured, and supports both free and authenticated tiers via the YDC\_API\_KEY environment variable. The tool returns structured results including titles, URLs, and extracted snippets, with configurable result limits and built-in URL safety checks. Also in this area: 14 commits (11 fixes) fixing backend.

backend/packages/harness/deerflow/community/youcom · medium confidence · unverified

Add backend .gitignore and test duration tracking

The backend directory now includes a .gitignore file to exclude Python build artifacts, virtual environments, local Claude settings, and the sandbox runtime working directory from version control. Additionally, a .test\_durations file has been added to track pytest execution times, enabling faster test runs by prioritizing or skipping tests based on historical performance data.

backend · high confidence

Add blog post structure and initial content

The blog section now supports a structured layout with post listing and tagging. A new \\_meta.ts\ file defines a 'Weekly' category, and initial content has been added, including a technical post on handling provider safety termination signals in tool-using agents, a release note for DeerFlow 2.0 M1, and the first weekly update.

frontend/src/content/en/posts · high confidence

Add browser notification support with rate limiting and settings integration

Users can now receive browser-based notifications through a new \useNotification\ hook in the core notification module. This feature integrates with local user settings to respect notification enable/disable preferences, checks for browser API support, and implements a 1-second rate limit to prevent notification spam. It also ensures the permission state is kept in sync with the actual browser state when showing notifications.

frontend/src/core/notification · high confidence

Add fastCRW web search and fetch tools with SSRF protections

Introduces a new fastCRW provider for web search and page fetching, reusing the Firecrawl client but allowing a configurable base URL for self-hosted deployments. The implementation includes SSRF guards: web\_fetch validates that target URLs are public HTTP(S) and refuses delegation to self-hosted backends unless network isolation is explicitly confirmed, while also normalizing the max\_results parameter before passing it to the provider.

backend/packages/harness/deerflow/community/fastcrw · high confidence

Add internationalization (i18n) support for English and Chinese

The frontend now supports English (en-US) and Chinese (zh-CN) locales. The system detects the user's browser language, persists the selected locale in a cookie, and provides translation dictionaries for both client-side components and server-side rendering. This enables localized content delivery across the application.

frontend/src/core/i18n · high confidence

Add memory pre-screening and signal classification adapters

Introduces a pluggable memory pre-screening system that acts as a cost gate to skip expensive extraction calls when a batch is unlikely to contain durable user information, and a signal classification system that provides reinforcement and correction hints based on user preference changes. Both systems support a shared TypeSafe client and offer dialects for OpenAI Decisions and TypeSafe (Jev) backends, allowing deployments to configure the backend, model, and thresholds via YAML. Also in this area: 5 commits (1 fix) modifying backend/packages/harness.

backend/packages/harness/deerflow/agents/memory/prescreen, backend/packages/harness/deerflow/agents/memory/signals, backend/packages/harness/deerflow/typesafe · medium confidence

New server-side API routes have been added to support serving static demo content for threads. The \/artifacts\ route now proxies file requests for thread artifacts, handling range requests and optional download headers. The \/history\ route fetches and normalizes thread history data from static JSON files, ensuring a consistent array format. The \/search\ route implements paginated and sorted search across all demo threads, allowing clients to filter and order results by creation or update time.

frontend/src/app/mock/api/threads · high confidence

Add opt-in advisory screening for fetched content in DeerFlow extensions

An example extension is added that screens text excerpts from remote tool results (web\_fetch, web\_search, image\_search, web\_capture, and MCP tools) for potential AI-directed instructions. When enabled via configuration, it sends bounded excerpts to a TypeSafe endpoint; if a score meets the threshold, a fixed advisory warning is prepended to the tool result before the model sees it. The feature is opt-in, does not block tool execution, and includes configuration for thresholds, timeouts, and excerpt limits.

examples/deerflow-extension-jev-screening · high confidence

Add read-only LightRAG retrieval integration

DeerFlow now supports read-only retrieval from LightRAG servers via a new community provider. This change introduces an asynchronous HTTP client that communicates with the LightRAG \/query/data\ endpoint, requiring LightRAG v1.4.9 or newer for full compatibility. The integration handles API key authentication via the \X-API-Key\ header, normalizes retrieval results into DeerFlow's standard \RetrievalResult\ format, and formats output with file-path citations. It supports naive, local, global, hybrid, and mix query modes, and deliberately excludes graph summaries (entities/relationships) to maintain a compact, citation-friendly response shape consistent with other RAG providers.

backend/packages/harness/deerflow/community/lightrag · high confidence

Add runtime API route for GitHub star count

A new server-side route at /github-stars has been added to fetch the public star count for the 'bytedance/deer-flow' repository. This endpoint retrieves the data at runtime using the GITHUB\_OAUTH\_TOKEN environment variable, caching the result for one hour via Next.js revalidation, and returns a 204 No Content response if the token is missing or the request fails, allowing the UI to gracefully hide the counter.

frontend/src/app/github-stars · high confidence

Add standalone Jev context pruning example plugin

An opt-in Python plugin example is added that uses the Jev service to shorten obsolete read-only tool results (read\_file, grep, glob, ls) before DeerFlow's normal summarization. It registers via the extension API 0.2.2, runs on the lead agent at MODEL\_LOGICAL, and replaces result contents in the persisted graph state with a compaction marker when the keep probability is below 0.2 and estimated reduction reaches 10%. The plugin is disabled by default and requires a TYPESAFE\_API\_KEY environment variable; it sends bounded conversation excerpts to https://api.typesafe.ai/v1/systemone. Configuration fields include trigger\_tokens (default 60000), min\_calls\_between\_attempts (default 16), and timeout\_seconds (default 8.0). The example includes verification scripts for package installation and live smoke testing.

examples/deerflow-extension-jev-context · high confidence

Add standalone text classification plugin example

An opt-in Python plugin is now available as an example that provides a \classify\_texts\ tool, allowing the agent to label a list of short texts with categories supplied in the call. The plugin supports two backends: Jev (TypeSafe System One) or an OpenAI-compatible chat endpoint, configured via deployment settings. It uses extension API 0.2.2 and integrates with the full-stack plugin catalog without requiring host code changes, enabling users to experiment with text classification capabilities.

examples/deerflow-extension-jev-classify · high confidence

Add workspace change review UI for agent runs

A new badge and side-panel interface has been added to the frontend to allow users to review file changes made during agent runs. The \WorkspaceChangeBadge\ component displays a count of edited files and a summary of additions/deletions, while clicking it opens a \WorkspaceChangePanel\ that lists individual files with their status (created, deleted, modified), line-level diffs, and links to open the files. This feature is specifically triggered by a \runId\, enabling users to inspect the workspace impact of a specific agent execution.

frontend/src/components/workspace/changes · high confidence

Added API routes for memory import and export

New Next.js API routes have been added at \frontend/src/app/api/memory\ and \frontend/src/app/api/memory/\[...path\]\ to proxy memory-related requests to the backend. These routes support GET, POST, DELETE, and PATCH methods, allowing the frontend to import and export memory data by forwarding requests to the backend service (defaulting to port 8001).

frontend/src/app/api · high confidence

Added Blocking-IO Guard skill for async event loop protection

Introduced a new agent skill that provides a standard operating procedure for identifying and fixing blocking I/O operations that could stall the asyncio event loop. The skill includes a static scanning script to detect candidates in changed code or the full repository, along with reference documentation and a test template for creating 'runtime anchors'—tests that verify blocking calls are properly offloaded. This ensures that backend changes in Python modules are accompanied by verified safeguards against event loop blocking.

.agent/skills/blocking-io-guard · high confidence

Added Chinese introduction documentation for DeerFlow

New Chinese-language documentation pages have been added to the frontend content structure, covering the introduction section. This includes an index page, a 'Why DeerFlow' page explaining the runtime harness concept, a 'Core Concepts' page detailing long-horizon agents, skills, sandboxes, and memory, and a 'Harness vs. App' page distinguishing the Python SDK from the deployed application. These files establish the navigation metadata and content for the Chinese user base.

frontend/src/content/zh/harness, frontend/src/content/zh/introduction · high confidence

Added Chinese localization for documentation site navigation and overview

Users can now access the documentation in Chinese, starting with the main overview page (index.mdx) which introduces the DeerFlow framework, its Harness runtime, and application layers. The navigation structure (\_meta.ts) has been translated to include sections for Introduction, Harness, Application, Tutorials, Reference, Blog, Posts, Login, and Setup, enabling Chinese-speaking users to browse and understand the product's capabilities and deployment options.

frontend/src/content/zh · high confidence

Added Chinese-language blog content and navigation structure

This change introduces the Chinese localization for the blog section by adding a meta configuration file that defines the 'Weekly' (周报) section title, and includes new documentation posts: a release note for DeerFlow 2.0 RC, a weekly update for April 6, 2026, and a technical article explaining how tool-based agents should handle safety termination signals from model providers.

frontend/src/content/zh/posts · high confidence

Added demo thread for generating a static Jiangsu football league website

A new demo thread (5aa47db1...) has been added to the frontend public directory, capturing a conversation where the AI generates a complete static website for the 'Jiangsu City Football League 2025 Season'. The output includes a full set of static assets: an HTML entry point with navigation and hero sections, a comprehensive CSS stylesheet with dark mode support and animations, a JavaScript data file containing league standings and team details, and a main script handling UI interactions like theme toggling and scroll spying. This entry demonstrates the system's capability to produce multi-file static site outputs from a single user request.

frontend/public/demo/threads/5aa47db1-d0cb-4eb9-aea5-3dac1b371c5a · high confidence

Adds Monocle telemetry support alongside existing LangSmith and Langfuse tracing

DeerFlow now supports Monocle as a third observability provider, in addition to the existing LangSmith and Langfuse integrations. When the \MONOCLE\_TRACING\ environment variable is set, the system initializes a process-global OpenTelemetry tracer via the \monocle\_apptrace\ library, which auto-instruments OpenAI, LangChain, and LangGraph clients. This setup is performed once during the Gateway lifespan (or manually by embedded clients) and coexists with Langfuse by sharing the global tracer provider, allowing both to capture spans. Users can configure Monocle exporters (such as file, console, S3, or GCS) via \MONOCLE\_EXPORTERS\ and \OKAHU\_API\_KEY\.

backend/packages/harness/deerflow/tracing · high confidence

Clipboard fallback and static website mode support

The application now includes a robust clipboard utility that ensures copy functionality works even in environments where the standard Clipboard API is unavailable or restricted, by falling back to legacy document.execCommand methods and patching the navigator object when necessary. Additionally, a new static website mode has been introduced, allowing the application to detect and operate in a static-only context based on environment configuration.

frontend/src/core · high confidence

Configurable backend and LangGraph base URLs via environment variables

The frontend now supports externalizing the backend and LangGraph service endpoints through the new environment variables NEXT\_PUBLIC\_BACKEND\_BASE\_URL and NEXT\_PUBLIC\_LANGGRAPH\_BASE\_URL. When these variables are set, the application constructs full URLs relative to the base origin, allowing users to connect to remote or custom service instances instead of relying on the default local development paths. If the variables are not provided, the system falls back to constructing URLs based on the current window origin or specific local defaults (such as localhost:2026 for SSR), ensuring compatibility with existing setups while enabling flexible deployment configurations.

frontend/src/core/config · high confidence

Declarative agent factory and structured runtime features

The agent assembly now uses a new \create\_deerflow\_agent\ SDK entry point that accepts plain Python arguments and a \RuntimeFeatures\ dataclass for declarative feature flags (sandbox, memory, summarization, subagent, vision, auto\_title, guardrail, loop\_detection, token\_budget). This factory supports explicit middleware takeover, custom middleware insertion via \@Next\/\@Prev\ decorators, and optional direct subagent runtime injection for isolated capacity boundaries. Thread state management is enhanced with delta-mode checkpoint channels, configurable snapshot frequency, and specialized reducers for artifacts, viewed images, goals, promoted tools, and a capped delegation ledger. Interaction policies now distinguish interactive, autonomous, webhook, and scheduled modes, controlling clarification tool availability and system prompt guidance. Assembly descriptors provide a comparable identity of the assembled agent by hashing model identity, middleware parameters, and tool schemas without copying payloads.

backend/packages/harness/deerflow/agents · high confidence

Declarative capability catalog and bundled business integrations

The system now uses a declarative capability catalog to manage plugins and integrations. A new \builtin.json\ manifest defines bundled business tools for Lark, DingTalk, WeCom, and HubSpot, including their configuration schemas and authentication methods. The \capabilities\ package provides the runtime logic to load this catalog, validate manifests, and execute the bundled business tools via a secure stdio MCP lifecycle that keeps credentials in environment variables rather than tool arguments. This replaces ad-hoc integration handling with a unified, validated discovery and execution model.

backend/packages/harness/deerflow/config · high confidence

DeerFlow agent middleware documentation and core implementation

The middleware layer for DeerFlow agents is now documented and implemented, providing a structured, ordered chain of capabilities including input sanitization, tool output budgeting, PII redaction, sandbox auditing, authorization guardrails, artifact capture, and loop detection. This change introduces the foundational middleware architecture (including the BoundedDict for state management) and detailed specifications for how these components interact to secure, optimize, and observe agent tool usage and context management.

backend/packages/harness/deerflow/agents/middlewares · high confidence

DeerFlow harness introduces declarative agent features, interaction policies, and memory management

The harness package now provides a structured foundation for building and managing DeerFlow agents. It introduces a \RuntimeFeatures\ dataclass to declaratively configure agent capabilities (such as sandbox, memory, summarization, and loop detection) and middleware positioning via \@Next\ and \@Prev\ decorators. A new \RunInteractionPolicy\ system standardizes how agents handle clarification and autonomous decision-making across interactive, webhook, and scheduled modes. Additionally, the harness includes a robust memory subsystem with a debounced update queue, a deterministic fact eviction policy (supporting hybrid scoring based on confidence, confirmation freshness, and access heat), and a pluggable memory judging layer for pre-screening and signal classification.

deerflow-harness · high confidence

DeerFlow terminal workbench (TUI) initial release

The \deerflow\ terminal workbench is now available as a native TUI over the embedded harness, exposed via the \deerflow\ console script. It provides a full interactive interface including a composer with multiline paste support, slash-command palette, thread switching, and transcript rendering. The TUI integrates with the Web UI by writing thread metadata to the shared database, ensuring sessions started in the terminal appear in the Web UI sidebar. It also includes robust error handling for LLM fallbacks, input history preservation, and graceful degradation when the \textual\ dependency is absent. Also in this area: 5 commits (1 fix) modifying backend/packages/harness.

backend/packages/harness/deerflow/tui · medium confidence · unverified

DeerMem backend configuration and initialization structure

The DeerMem memory backend now exposes a dedicated configuration module and package structure. A new \\\_\init\\_.py\\ file initializes the \\deermem\\ package, while \\config.py\\ defines the \\DeerMemConfig\\ and \\DeerMemModelConfig\\ Pydantic models. These models parse the \\backend\_config\\ dictionary passed from the host, allowing users to configure storage paths, retrieval adapters (such as FTS5), fact deduplication gates, relevance-aware ranking, eviction policies, and LLM parameters for memory updates. This change establishes the self-contained configuration layer for the DeerMem backend, separating its private settings from the shared \\MemoryConfig\\. Also in this area: 26 commits (21 fixes) fixing backend; Fixes for unhashable content blocks, fork-bomb detection, and memory debounce starvation; Optional memory pre-screening and signal classification via TypeSafe judge.

backend/packages/harness/deerflow/agents/memory/backends/deermem/deermem · medium confidence · unverified

DeerMem memory backend core extracted with externalized prompts and tolerant Markdown storage

The DeerMem memory backend's functional core has been extracted into a self-contained module (\deermem.core\), introducing an opt-in \MarkdownMemoryStorage\ that tolerates corrupt or hand-edited memory summaries by quarantining unreadable files instead of crashing the agent. Memory update logic now relies on externalized YAML prompt templates (loaded via \load\_prompt\ and \load\_prompt\_messages\) and signal patterns (e.g., correction, preference, goal) that can be overridden per-agent without code changes. The backend also implements its own LLM construction fallback, path resolution, and message processing pipeline, decoupling memory management from the host application's internal structures.

backend/packages/harness/deerflow/agents/memory/backends/deermem/deermem/core · high confidence

First-class Helm chart for Kubernetes deployment

DeerFlow now provides a complete, production-ready Helm chart for deploying the application on Kubernetes. The chart manages the full stack, including the gateway, frontend, Nginx ingress, and an optional bundled PostgreSQL database and Redis stream bridge. It introduces multi-replica support for the gateway and provisioner, ensuring session consistency via shared secrets and proper termination grace periods. The deployment includes hardened security defaults (non-root containers, dropped capabilities) and robust configuration for sandbox provisioning, including configurable service types (ClusterIP or NodePort) and persistent volume claims for user data.

deploy/helm/deer-flow/templates · high confidence

Frontend skills management and slash-command integration

The frontend now includes a dedicated skills module that enables users to install, enable, and export custom skills. This change introduces API clients for loading the skill catalog, toggling skill states, uploading skill archives, and exporting custom skill packages as version-bound ZIP files. It also adds React Query hooks to manage these operations and a slash-command parser that reserves specific command names (like /context and /agent) while allowing activation of enabled custom skills via /skill-name syntax. Additionally, the system captures and displays skill usage evidence within conversation history, showing which skills were automatically or manually triggered during assistant responses.

frontend/src/core/skills · high confidence

Gateway API documentation and core application structure introduced

The backend gateway now includes a comprehensive AGENTS.md specification detailing the API surface, including new endpoints for managed models, knowledge retrieval, console observability, MCP configuration, skills, subagents, and GitHub integrations, alongside security hardening for artifacts and uploads. The application module structure is established with lazy initialization in \_\init\\_.py and a new app.py entry point that wires up middleware (CORS, CSRF, Auth, Trace), routers, and startup/shutdown lifecycle hooks, including a first-boot setup flow and orphan thread migration for users upgrading from unauthenticated modes. Also in this area: 11 commits (6 fixes) fixing backend; Fix Docker signal handling and document IM channel leadership leases; IM channel shutdown and streaming fixes; Fixes for DingTalk table rendering, WeChat config validation, and Feishu proactive notifications; Feishu clarification cards, goal validation, scheduler delay fix, and orphan recovery signals; and 2 more.

backend/app/gateway · medium confidence · unverified

IM Channels System Architecture and Implementation Documentation

Added comprehensive documentation for the IM Channels system (\backend/app/channels/AGENTS.md\) detailing the integration of external messaging platforms (Feishu, Slack, Telegram, Discord, DingTalk, GitHub, Buzz/Nostr, WeChat, WeCom, QQ) with the DeerFlow agent via the Gateway's LangGraph-compatible API. The documentation covers the message flow from inbound platform events through the \MessageBus\ and \ChannelManager\ to outbound replies, including specific implementation details for each channel type (e.g., streaming updates for Feishu/Telegram, fire-and-forget for GitHub, NIP-42 authentication for Buzz). It also documents user-owned channel connections, owner-scoped file storage, configuration options, and security considerations such as credential management and URL redaction in logs.

backend/app/channels · high confidence

Image search tool now supports color, license, and layout filters with improved URL safety

The image\_search tool now exposes additional DuckDuckGo filters—color, license\_image, and layout—allowing users to refine search results by palette, usage rights, and aspect ratio. The tool also normalizes Unicode host separators in URLs and reuses a shared safety check to screen image, thumbnail, and source page URLs against blocked addresses before returning them. To prevent blocking the agent loop, the search execution is offloaded to a background thread, and errors are clearly distinguished from empty results.

_backend/packages/harness/deerflow/community/image\search · high confidence

InfoQuest web and image search tools with result safety and timeout handling

The InfoQuest community integration now provides web and image search capabilities via new LangChain tools. The client has been migrated to use httpx.AsyncClient for asynchronous HTTP requests, with bounded connect and read timeouts to prevent hanging. Search result URLs are screened through the shared public-URL safety checker to ensure only safe, public links are returned, and malformed or invalid payloads are contained rather than causing crashes. Additionally, crawl timeouts are coerced from configuration values to integers before comparison, preventing type errors when non-numeric values are provided.

backend/packages/harness/deerflow/community/infoquest · high confidence

Initial frontend project scaffolding and configuration

The frontend directory has been initialized with a complete Next.js 16 project structure, including environment variable templates, build configurations, and development tooling. This establishes the foundation for the web interface, featuring a Dockerfile for containerized builds, a Makefile for standard operations, and ESLint/Prettier configurations to enforce code quality. The setup also includes Playwright E2E test configurations for both mocked and real-backend scenarios, as well as Rstest for unit testing, ensuring the application is ready for development and testing workflows.

frontend · high confidence

Initial i18n infrastructure and English/Chinese locale files

The frontend now includes a new internationalization structure under \frontend/src/core/i18n/locales\, introducing \en-US.ts\ and \zh-CN.ts\ alongside a shared \types.ts\ definition. This adds the foundational translation keys for the UI, covering common actions (e.g., export, settings), the new Capability Center (plugins, skills, integrations), and extension management states. While the commit history references many features, this specific change establishes the localization scaffolding and initial English/Chinese content required to support those features.

frontend/src/core/i18n/locales · high confidence

Initial landing page and root layout for the web app

The frontend now includes a root layout (\layout.tsx\) that sets up the global theme provider and metadata, and a landing page (\page.tsx\) that serves as the default entry point. This page assembles a full-screen dark-themed interface composed of a header, hero section, case study, skills, sandbox, what's new, community sections, and a footer, establishing the basic structure for the web application.

frontend/src/app · high confidence

Initial release of the DeerFlow Extension API (v0.2.9)

The \backend/packages/extension-api\ package is introduced as a stable, host-independent contract layer for building extensions. This new API exposes public interfaces for agent run observation, middleware plugin foundations, structured model tool artifacts, and run evidence reading, while providing typed storage (\ExtensionData\) and runtime bridging to keep extension state isolated from the host. The package is versioned at 0.2.9, indicating that minor versions may contain breaking changes until the API reaches 1.0.

backend/packages/extension-api · high confidence

Introduce AIO Sandbox with controlled egress and Lark CLI integration

This change introduces the AIO Sandbox module, providing a new sandboxing infrastructure for DeerFlow. It adds a network policy proxy that enforces controlled egress, allowing outbound traffic only via an approval-based allowlist or static rules, which enhances security by preventing unauthorized network access from sandboxed agents. Additionally, it integrates Lark CLI support, including a sidecar credential broker (Pattern B) to keep credentials isolated from the sandbox environment, and provisions specific mount paths for Lark configuration and data. The module also includes a quarantine system to manage sandbox lifecycle states and prevent resource leaks, along with local and remote backends for provisioning sandboxes in Docker or Kubernetes environments.

_backend/packages/harness/deerflow/community/aio\sandbox · high confidence

Introduce Browserless web capture and fetch tools with SSRF protection

Adds new \web\_capture\_tool\ and \web\_fetch\_tool\ components to the community harness, enabling users to capture screenshots and fetch web content via a Browserless service. The implementation includes robust security measures, specifically an SSRF guard that validates target URLs and restricts delegation to self-hosted backends unless network isolation is explicitly confirmed. It also supports configurable timeouts, output formats, and atomic file publishing to ensure reliable and safe operation.

backend/packages/harness/deerflow/community/browserless · high confidence

Introduce E2B cloud sandbox provider

Adds a new \E2BSandboxProvider\ and \E2BSandbox\ implementation that delegates DeerFlow's sandbox operations to the E2B cloud SDK. This enables users to run code in remote, ephemeral cloud environments instead of only local containers, with configuration options for API keys, templates, idle timeouts, and file mounts. The provider includes a lifecycle management system with Redis-based ownership coordination, automatic reconciliation of orphaned sandboxes, and specific fixes for remote file search (grep/glob) to correctly handle special characters, path scoping, and output parsing.

_backend/packages/harness/deerflow/community/e2b\sandbox · high confidence

Introduce Firecrawl tools with SSRF protection and resource cleanup

Added new \web\_search\ and \web\_fetch\ tools using the \AsyncFirecrawlApp\ SDK. The \web\_fetch\ tool now enforces strict URL validation to prevent Server-Side Request Forgery (SSRF) by blocking private addresses and requiring explicit operator confirmation for delegated backends. Additionally, the implementation ensures proper cleanup of the underlying async HTTP connection pool after each tool invocation to prevent resource leaks.

backend/packages/harness/deerflow/community/firecrawl · high confidence

Introduce GitHub as a webhook-driven channel

The system now supports GitHub as a first-class webhook-driven channel, enabling custom agents to react to pull requests, issues, and reviews. This change introduces a new dispatcher pipeline that verifies webhooks, filters events based on per-binding trigger configurations (such as action whitelists and mention requirements), and routes relevant events to the agent bus. It includes logic to prevent self-referential loops, deduplicate redundant review-comment fan-out, and ensure deterministic thread IDs for consistent agent state. Agents can now be bound to specific repositories and events, with run policies handling GitHub App authentication and managing concurrency limits.

backend/app/gateway/github · high confidence

Introduce Live Browser View with reliable WebSocket streaming

Adds a new Live Browser feature that streams a remote browser's screen via WebSocket, allowing users to interact with web pages in real-time. The implementation includes a 10-second handshake timeout to prevent hanging connections, bounded exponential backoff for reconnection attempts, and a seed URL mechanism to ensure the browser lands on the expected page after reconnects. The UI provides a toggleable panel with live navigation, keyboard input forwarding, and frame buffering for smooth display.

frontend/src/components/workspace/browser-view · high confidence

Introduce MCP Task Service for long-running background tasks

Added a new \McpTaskService\ in \backend/app/mcp\_tasks\ to manage, persist, and poll long-running MCP tasks outside the main agent loop. This service handles task lifecycle management including claim ownership, cancellation safety, and notification delivery, exposing a \McpTaskService\ class and a \PermanentNotificationError\ for error handling.

_backend/app/mcp\tasks · high confidence

Introduce MCP server configuration management in the frontend

The frontend now includes a dedicated module for managing Model Context Protocol (MCP) server settings. This change adds the core API layer, React Query hooks, and type definitions required to load, create, update, and delete MCP server configurations via the backend. It also introduces utilities for parsing and validating server definition snippets (including copy-paste support) and handling plugin icons, enabling users to configure and toggle MCP servers directly from the application settings.

frontend/src/core/mcp · high confidence

Introduce Next.js App Router layout and page for chat threads

The chat thread view is now structured using the Next.js App Router, with a new layout file that wraps the chat interface in ChatProviders and a page file that renders the ChatPage component. In static website mode, the layout generates static paths for all demo thread IDs to ensure proper routing for pre-rendered content.

_frontend/src/app/workspace/chats/\[thread\id\] · high confidence

Introduce OpenViking memory backend with official LangChain integration

DeerFlow now supports OpenViking as a memory backend, using the official LangChain adapter for transport, batching, and retrieval. The backend enforces strict configuration validation, including mandatory user API keys, secure URL schemes, and defined failure policies for reads and writes. It provides stable session identity and message capture tracking to ensure reliable memory injection and retrieval for agents.

backend/packages/harness/deerflow/agents/memory/backends/openviking · high confidence

Introduce Projects with document management and thread integration

This change introduces the Projects feature, providing a dedicated workspace for organizing conversations and files. Users can now create and manage projects, which include a 'Document Shelf' for uploading and organizing files, and a 'Conversation Files' view that groups files by their source threads. The implementation includes a cross-route handoff mechanism that allows users to attach project documents directly to chat threads, persisting the attachment state across navigation. Projects support active and archived states, with specific UI handling for archived projects that restricts mutation actions while preserving read access. Also in this area: 3 commits (1 fix) modifying frontend.

frontend/src/components/workspace/projects · medium confidence · unverified

Introduce RAGFlow as a read-only knowledge provider with verifiable source citations

DeerFlow now supports RAGFlow as a read-only knowledge source, enabling users to search datasets and retrieve document chunks via a new community provider. The implementation includes a dedicated HTTP client for RAGFlow APIs, catalog browsing for datasets and documents, and scoped retrieval that respects user-selected dataset and document filters. A key feature is the introduction of verifiable source citations: retrieval results are formatted with unique, per-call citation links that resolve to bounded, immutable evidence snapshots in the artifact. These snapshots preserve the exact excerpts sent to the model, redact credentials, and handle output budgeting by omitting entire source records if they exceed limits, ensuring that cited evidence remains consistent and auditable. The provider also supports durable batch exports that retain these source artifacts, allowing users to trace model responses back to specific RAGFlow document chunks.

backend/packages/harness/deerflow/community/ragflow · high confidence

Introduce RAGFlow knowledge scope management and verifiable source citations

The frontend now supports selecting specific knowledge bases and documents for agent retrieval via a new scope system (defined in \scope.ts\ and exposed via \scope-api.ts\), allowing users to restrict RAG queries to a curated subset of data. Additionally, the system integrates with RAGFlow to provide verifiable source citations, extracting and displaying provenance details such as document names, dataset names, and page numbers directly from tool artifacts in the conversation history.

frontend/src/core/knowledge · high confidence

Adds a new Serper-based provider for both web and image search capabilities. This includes configurable source-domain filters (include/exclude), support for relative search time ranges, opt-in bounded transient retries, and a configurable base URL. The implementation also enforces strict validation for API keys, result URL safety, and malformed response handling to ensure reliable search results.

backend/packages/harness/deerflow/community/serper · high confidence

Introduce abstract RunStore interface and in-memory implementation

The runs store module now exposes a formal abstract interface (RunStore) for run metadata storage, alongside a concrete in-memory implementation (MemoryRunStore) used for development and testing. This change introduces support for tracking model names, stop reasons, and lease-based ownership (including renewal and cancellation actions) within run records, and adds efficient per-thread indexing to avoid full scans when listing run history.

backend/packages/harness/deerflow/runtime/runs/store · high confidence

Introduce background task management for MCP operations

Added a new frontend module to monitor and control long-running Model Context Protocol (MCP) tasks. Users can now view the status of background tasks (such as submitted, working, or failed) and explicitly cancel them via the UI. The system automatically polls for updates while tasks are active and provides detailed information including notification states and result previews. Also in this area: 5 commits (2 fixes) modifying frontend.

frontend/src/core/background-tasks · medium confidence · unverified

Introduce built-in general-purpose and bash subagents with sandbox-aware configurations

Deerflow now includes two built-in subagent configurations—general-purpose and bash—registered in the harness. The general-purpose subagent is configured with a 150-turn limit and a system prompt that prohibits the \task\ tool to prevent nesting, while also providing specific guidance on file editing workflows (preferring \str\_replace\ and chunked \write\_file\ calls) to mitigate streaming timeouts on long reports. The bash subagent is limited to sandbox tools (bash, ls, read\_file, write\_file, str\_replace), disallows the \task\ tool, and includes explicit instructions to use workspace-relative paths and respect sandbox mount points (e.g., \/mnt/user-data/workspace\).

backend/packages/harness/deerflow/subagents/builtins · high confidence

Introduce checkpoint history cache with memory and Redis backends

Added a new checkpoint history cache system to improve performance by caching delta-history data. The implementation includes a process-local in-memory LRU backend (MemoryCheckpointHistoryCache) and a shared Redis backend (RedisCheckpointHistoryCache), managed via a factory provider that selects the backend based on configuration. The cache supports thread-scoped purging for lifecycle management, handles serialization failures gracefully by treating corrupt or unserializable entries as misses, and uses deployment-specific key prefixes to prevent collisions when multiple deployments share a Redis instance.

_backend/packages/harness/deerflow/runtime/checkpoint\cache · high confidence

Introduce core channel management and WeChat QR login support

This change adds the frontend core logic for managing external messaging channels, enabling users to connect, configure, and disconnect providers such as Telegram, Slack, and Discord. It introduces a deterministic connection flow using a polling mechanism to track connection status and ensure reliable state updates. Additionally, it adds support for WeChat QR code login, allowing users to authenticate and bind WeChat accounts via a web-based QR scan flow. The update also includes a new notification preferences system, letting users opt-in to receive IM notices for specific events (like run completion or failure) through channels like WeChat, QQ, and WeCom.

frontend/src/core/channels · high confidence

Introduce core file upload infrastructure with validation and error handling

This change adds the foundational module for file uploads in the frontend, introducing API functions to upload, list, and delete files within a thread, along with React Query hooks to manage this state. It includes client-side validation logic that enforces gateway-defined limits (max file size, max file count, and total size) and specifically blocks unsupported macOS .app bundles. Additionally, it implements robust error handling that parses structured API error details for user-facing feedback and ensures uploaded filenames are correctly encoded during deletion requests.

frontend/src/core/uploads · high confidence

Introduce cross-instance ownership leases for shared sandbox containers

Added a new ownership subsystem (\backend/packages/harness/deerflow/community/aio\_sandbox/ownership\) that manages lease-based ownership of shared sandbox containers across multiple gateway instances. This prevents one instance from accidentally adopting and destroying a container actively used by a peer (fixing issue \#4206). The system supports both in-memory (single-instance) and Redis-backed (multi-instance) stores, with the latter using Lua scripts for atomic lease operations and two-state tracking (\own\/\del\) to safely handle teardown windows. It also includes logic to reject overflowing lease TTLs and enforce deployment-wide capacity limits.

_backend/packages/harness/deerflow/community/aio\sandbox/ownership · high confidence

Introduce dedicated /chats page with pagination, search, and archive management

The new frontend/src/app/workspace/chats/page.tsx component provides a centralized interface for managing chat threads. It supports infinite scrolling with an intersection-observer-based sentinel for active chats, while search mode disables auto-pagination to prevent excessive backend requests, requiring explicit user action to load older results. Users can now filter chats by title, view active versus archived threads via tabs, and restore archived chats directly from the list. The page also includes dynamic i18n titles and handles error states with retry options.

frontend/src/app/workspace/chats · high confidence

Introduce dedicated chat layout and page components for custom agent threads

This change establishes the frontend structure for individual chat threads within custom agents by adding a new layout component that wraps the chat interface with necessary providers, and a new page component that renders the full chat experience. The page component integrates core chat functionalities including message streaming, token usage indicators, knowledge scope selection, and thread management, effectively creating the dedicated UI for interacting with a specific agent's conversation history.

_frontend/src/app/workspace/agents/\[agent\name\] · high confidence

Introduce durable background task runtime for MCP toolsets

Users can now run long-running MCP tools as background tasks with persistent state, rather than blocking synchronous calls. This change adds the core runtime foundation in the tasks module, including a driver registry for protocol adapters, a submitter interface for submitting and listing tasks, and configuration validation that enforces durable SQL persistence (SQLite or Postgres) and requires explicit enabling via \mcp\_tasks.enabled=true\. It also introduces OAuth state sharing for task-enabled servers and validates that configuration changes do not split tool discovery from background execution, ensuring reliable task recovery and status tracking.

backend/packages/harness/deerflow/mcp/tasks · high confidence

Introduce feature-flag API and React hooks for frontend capabilities

The frontend now queries the backend's \/api/features\ endpoint to dynamically determine which capabilities are available, exposing this state through dedicated React Query hooks. This change adds support for checking and reacting to the availability of browser control, MCP tasks, subagent batches, conversation references, knowledge base scope selection, scheduled tasks, and thread activity, allowing the UI to conditionally render features based on the server's configuration.

frontend/src/core/features · high confidence

Introduce managed subagent configuration and management API

This change adds the frontend infrastructure for managing user-defined subagents. It introduces a new API layer (\api.ts\) to create, update, list, and delete managed subagents via backend endpoints, along with React Query hooks (\hooks.ts\) to handle data fetching and mutations. The \types.ts\ file defines the data structures for subagents, including properties like name, model, tools, and source type, enabling users to configure and control specific subagent behaviors.

frontend/src/core/subagents · high confidence

Introduce new Agents workspace UI with per-agent configuration and capability selection

The Agents workspace now features a dedicated gallery view for browsing and managing custom agents, including a new settings dialog that allows users to configure per-agent model selection, temperature, max tokens, thinking/reasoning effort, and knowledge scopes. Users can also select specific MCP plugins and skills for each agent via a new capability selection component, and agent cards now intelligently truncate long labels with tooltips to prevent layout overflow.

frontend/src/components/workspace/agents · high confidence

Introduce new chat workspace UI components and state management

This change introduces the core frontend components for the chat workspace, including \ChatPage\, \ChatBox\, and \ChatProviders\, along with hooks for managing thread state (\useThreadChat\) and specific chat modes (\useSpecificChatMode\). The new \ChatBox\ component implements a resizable panel layout that dynamically switches between sidecar, artifacts, browser, and message details views, while \ChatPage\ handles thread lifecycle, knowledge scope selection, and permission-based UI gating. The \useThreadChat\ hook manages thread identity, new-chat state, and project scoping, ensuring stable thread IDs during navigation and preventing stale history requests.

frontend/src/components/workspace/chats · high confidence

Introduce opt-in Agent Teams collaboration plugin

Adds a new, independently installable plugin that enables multiple Custom Agents to collaborate within a shared team context. Users can create teams of 2–8 agents, assign goals, and delegate tasks using @mentions or the \send\_member\ tool, with results returned asynchronously. The plugin provides a dedicated UI for managing teams, viewing activity feeds, and handling clarifications, while persisting team state, history, and results in a local SQLite database. It enforces strict bounds on data (e.g., 24,000 UTF-8 byte response limits, 100-request caps) and ensures isolation from host internals, requiring only public extension contracts and a Gateway restart to enable.

examples/deerflow-extension-agent-teams · high confidence

Introduce opt-in script workflows with versioned orchestration and human checkpoints

Operators can now enable a new 'Script workflows' extension that runs bounded, inspectable JavaScript orchestration in the background. This feature allows scripts to call full DeerFlow Agents, fan out parallel tasks, and pause for human approval via authenticated checkpoints. It supports versioned, immutable script definitions, durable recovery after restarts, and optional PostgreSQL-backed multi-Gateway coordination with execution leases. The extension is disabled by default and requires explicit configuration of allowed agents, storage paths, and concurrency limits.

_examples/deerflow-extension-workflows, examples/deerflow-extension-workflows/deerflow\_extension\workflows · high confidence

Introduce pre-execution tool authorization and risk gating

DeerFlow now intercepts tool calls before they execute, evaluating them against a pluggable authorization provider. A built-in allowlist provider enforces explicit allow/deny lists, with a critical fix ensuring that an empty allowlist correctly denies all tools rather than failing open. Additionally, a TypeSafe (Jev) provider is available to gate calls based on a risk probability threshold, preventing potentially irreversible or out-of-scope side effects. All authorization decisions are persisted as run events for auditability.

backend/packages/harness/deerflow/guardrails · high confidence

Introduce project workspaces with document shelves and scoped threads

Users can now organize conversations into Projects, which provide a dedicated workspace containing scoped threads and a document shelf. This change adds the core frontend infrastructure for Projects, including API clients and React Query hooks to manage project creation, updates, archiving, and restoration, as well as to list and paginate project-specific threads. It also introduces the ability to attach documents from the project shelf to threads, with a session-based handoff mechanism that ensures attachments persist across navigation and survive upload failures or page reloads. Additionally, the system supports best-effort LLM-generated summaries for shelf documents and handles the display of untitled threads in the conversation-files view.

frontend/src/core/projects · high confidence

Introduce scheduled task execution with interval, cron, and one-time schedules

The scheduler now supports creating conversation schedules with three distinct types: one-time, cron-based, and interval. Users can define tasks that run at a specific time, on a recurring cron expression, or at fixed second intervals. The system handles timezone validation and normalizes cron expressions, while also ensuring correct behavior during daylight saving time transitions for fixed-time tasks. Additionally, users can set stop conditions to pause schedules automatically, and the system provides clear error notes for interruptions such as gateway restarts or lease losses.

backend/packages/harness/deerflow/scheduler · high confidence

Introduce scheduled task notifications via an IM outbox

The scheduler now delivers instant messaging notifications for scheduled task outcomes (such as completion, goal attainment, or failure) through a dedicated outbox system. A new \\NotificationDeliveryWorker\\ polls this outbox and pushes messages to user-connected channels, while \\notification\_text.py\\ handles localized message rendering and redacts sensitive data before sending. This ensures users receive timely, secure updates about their automated runs directly in their preferred IM platform. Also in this area: 14 commits (11 fixes) fixing backend; Fix Docker signal handling and document IM channel leadership leases; Fixes for DingTalk table rendering, WeChat config validation, and Feishu proactive notifications.

backend/app/scheduler · medium confidence · unverified

Introduce scheduled tasks management interface

Users can now create, edit, and manage scheduled tasks directly from the workspace. The new page allows configuring task titles, prompts, and schedules (including cron and interval types), selecting specific agents to run the tasks, and filtering or searching through existing tasks. It also provides visibility into task status and run history.

frontend/src/app/workspace/scheduled-tasks · high confidence

Introduce sidecar panel for quoted follow-ups and text selection

This change adds a new sidecar panel component to the workspace, enabling users to initiate threaded conversations based on quoted text or selected fragments from the main chat. The implementation includes a context provider to manage sidecar state (such as active references and thread IDs), a trigger button to open/close the panel, and a panel UI that supports sending messages with attached context. It also introduces a reference attachment summary component to display and clear selected text fragments, effectively adding a new interaction mode for follow-up discussions within the workspace.

frontend/src/components/workspace/sidecar · high confidence

Introduce structured memory management with import, export, and fact editing

The frontend now includes a dedicated memory subsystem that allows users to import and export their memory data, as well as manually add, edit, and delete individual memory facts. This change introduces a new \UserMemory\ data model that structures memory into user context (including work, personal, top-of-mind, and cognitive style) and history sections, alongside a list of facts with confidence scores. The implementation provides React Query hooks for loading, clearing, and mutating memory state, along with robust normalization logic to handle legacy or malformed import payloads gracefully.

frontend/src/core/memory · high confidence

Introduce unified event store with stable message identity and sequence stamping

The runtime now uses a unified \RunEventStore\ interface to persist and retrieve run events, supporting memory, database (SQLAlchemy), and JSONL backends. To ensure the UI correctly aligns messages between the live feed and saved checkpoints, the system now attaches a stable identity to each message (using \tool\_call\_id\ for tool outputs and normalized IDs for human messages) and stamps messages with a thread-global sequence number (\deerflow\_seq\). This prevents display issues where early messages might be misplaced after context compaction or when loading from a checkpoint without a live stream.

backend/packages/harness/deerflow/runtime/events/store · high confidence

Introduce unified store persistence layer with async and sync providers

DeerFlow now provides a dedicated store persistence layer that supports memory, SQLite, and PostgreSQL backends. The new \runtime/store\ package exposes an async factory (\make\_store\) for long-running servers and a sync singleton/context manager (\get\_store\, \store\_context\) for CLI tools and embedded clients. The store respects the unified \database\ configuration section (falling back to the legacy \checkpointer\ section if present) and ensures PostgreSQL schemas are created before table setup. SQLite paths are automatically resolved and parent directories are created, while missing backend packages raise clear installation hints.

backend/packages/harness/deerflow/runtime/store · high confidence

Introduce user interface for scheduled tasks

Adds the frontend components for the scheduled tasks feature, including a task list and detail view that display run history, status, and goal outcomes, along with dialogs for creating, editing, and deleting tasks, renewing run limits, and binding Feishu group notifications.

frontend/src/components/workspace/scheduled-tasks · high confidence

Introduce verifiable RAGFlow source citations and evidence panel

The frontend now supports verifiable citations from RAGFlow knowledge sources. A new \sources.ts\ module defines the data structures for \CitationSource\ and \RetrievalSource\, and implements logic to parse and validate knowledge artifacts from tool messages, ensuring strict schema compliance and sanitization. This enables the display of an evidence panel that links inline citations to their specific source excerpts, providers, and metadata, enhancing traceability for retrieved information.

frontend/src/core/citations · high confidence

Introduce workspace change review for agent runs

Adds a new capability to fetch and display workspace changes resulting from agent runs. This includes a new API client to retrieve change summaries and file-level details (including diffs, symlink status, and binary/sensitive flags), React Query hooks for data fetching, and utility functions to classify diff lines and sort changes by status (created, modified, deleted, or symlink\_created).

frontend/src/core/workspace-changes · high confidence

Introduce workspace change tracking and review for agent runs

A new \workspace\_changes\ module has been added to the backend to capture and report file-level changes within agent sandbox workspaces. This feature enables a review interface by scanning workspace and output roots, comparing file snapshots to detect created, modified, deleted, or symlinked files, and generating unified diffs. The implementation includes an API endpoint to retrieve these changes, configurable limits on scanned files and diff sizes, and specific exclusions for internal temporary files, browser frames, and externalized tool outputs to ensure only relevant user deliverables are tracked.

_backend/packages/harness/deerflow/workspace\changes · high confidence

Introduces configurable stream bridge with Redis support

The stream bridge module now supports pluggable backends for decoupling agent workers from SSE endpoints. Users can configure the bridge via \StreamBridgeConfig\ to use either the default in-memory implementation or a new Redis-based implementation (\RedisStreamBridge\). The Redis backend allows configuration of connection parameters, queue size, heartbeat intervals, and stream TTL, with automatic fallback to memory mode if no configuration is provided. The factory function \make\_stream\_bridge\ handles initialization and lifecycle management of the selected backend.

_backend/packages/harness/deerflow/runtime/stream\bridge · high confidence

Introduction of DeerMem as the default self-contained memory backend

The system now includes a new, self-contained memory backend named DeerMem, which serves as the default implementation for the pluggable MemoryManager interface. This backend encapsulates the core memory machinery—including storage, queue management, fact updating, prompt formatting, and message processing—within the \deermem\ package. It provides file-backed fact storage with debounced LLM extraction, supports tool-mode retrieval via case-insensitive substring search, and handles configuration through a dedicated \DeerMemConfig\ class. This change establishes the foundational architecture for backend onboarding while maintaining existing memory behaviors such as filter validation, correction detection, and injection formatting.

backend/packages/harness/deerflow/agents/memory/backends/deermem · high confidence

Introduction of global CSS theme and animation definitions

The frontend now includes a centralized \globals.css\ file that establishes the core visual design system. This file imports Tailwind CSS and defines custom CSS variables for the theme (including dark mode support via \@custom-variant dark\) and a suite of keyframe animations such as \fade-in\, \loading-bar\, \skeleton-entrance\, and \suggestion-in\. It also sets up specific styling rules for content elements like streaming list markers and configures inline source patterns to ensure Tailwind generates utility classes for text, spacing, and color variants used throughout the application.

frontend/src/styles · high confidence

MCP integration harness and configuration documentation

This change introduces the foundational MCP (Model Context Protocol) integration layer within the DeerFlow harness. It adds the \AGENTS.md\ design document detailing the durable task runtime, session pooling, OAuth handling, and credential injection strategies. The codebase adds the core client module (\client.py\) for building server parameters and configurations, a configuration normalization module (\config\_normalization.py\) to ensure consistent handling of transport aliases and presentation fields, and a context headers module (\context\headers.py\) for injecting per-request credentials into HTTP/SSE MCP calls. The \\\init\\_.py\ exposes the public API for tool caching and initialization.

backend/packages/harness/deerflow/mcp · high confidence

Mock API endpoints for Lark/Feishu CLI integration lifecycle

Added mock backend routes under the Lark integration path to simulate the full CLI integration lifecycle, including status checks, installation, configuration, credential switching, and authorization flows. These endpoints provide consistent mock responses for the Lark CLI (version v1.0.65), allowing the frontend to test installation states, credential management, and authentication verification without a live Lark/Feishu connection.

frontend/src/app/mock/api/integrations · high confidence

New AI UI component library for chat and workflow visualization

A new set of React components has been added to the frontend to support AI-driven chat interfaces and visual workflow builders. This includes a comprehensive chat system with message branching, context usage indicators, and code block rendering, as well as a node-based canvas for visualizing AI plans and chains of thought. These components provide the building blocks for richer, more interactive AI conversations and structured task planning.

frontend/src/components/ai-elements · high confidence

New DeerFlow smoke-test skill for end-to-end deployment verification

A new agent skill has been added to guide users through a full end-to-end smoke test of the DeerFlow deployment. The skill supports both local and Docker deployment modes, automatically selecting the best option based on user preference or network conditions. It orchestrates a six-phase workflow: pulling the latest code, checking environment dependencies (Node.js 22+, pnpm, uv, nginx for local; Docker and Compose for Docker), preparing configuration files, executing the deployment, and performing health checks on the frontend, API Gateway, and LangGraph-compatible API. A key feature is the \frontend\_check.sh\ script, which automatically detects if authentication is enabled and logs in a smoke-test user to verify protected routes rather than just the login page. The skill concludes by generating a structured test report using mode-specific templates.

.agent/skills/smoke-test · high confidence

New Docker-based development environment and production deployment stack

DeerFlow now ships with a complete Docker Compose setup for both development and production use. The development environment (docker-compose-dev.yaml) includes a new dev entrypoint script that handles dependency resolution, validation, and self-healing for the Python virtual environment before starting the gateway. The production stack (docker-compose.yaml) introduces a Redis-backed stream bridge for cross-worker SSE delivery, a Kubernetes sandbox provisioner service, and a readiness health probe for the gateway. Security is improved by defaulting the gateway to a single worker, binding the published port to loopback only, and keeping host CLI auth directories and the Docker socket unmounted by default (available via opt-in overlays).

docker · high confidence

New English documentation structure and navigation

The English documentation site now features a structured navigation menu defined in \_meta.ts, organizing content into distinct sections for Overview, Introduction, Harness, App, Tutorials, Reference, Workspace, Blog, Posts, Login, and Setup. The new index page provides a clear entry point, guiding users to the appropriate documentation path based on their goals: understanding the framework, building with the Harness SDK, or deploying the DeerFlow App.

frontend/src/content/en · high confidence

New Extensions documentation site and navigation structure

The documentation site now includes a dedicated Extensions section with a new navigation menu (\_meta.ts) and comprehensive content (index, middleware, observers, operations, and plugins pages). This provides users with a complete guide on how to build, install, configure, and operate DeerFlow extensions, including details on the extension API contract, middleware placements, lifecycle observers, and the experimental full-stack plugin system.

frontend/src/content/en/harness/extensions · high confidence

New Harness documentation section added

A new documentation section for the DeerFlow Harness has been added to the frontend, establishing the site structure and providing initial content for key concepts. The \\_meta.ts\ file defines the navigation hierarchy, including pages for Install, Quick Start, Design Principles, Lead Agent, Middlewares, Configuration, Memory, Tools, Skills, Sandbox, Subagents, Checkpoints, MCP Integration, Extensions, Customization, and an Integration Guide. The accompanying MDX files introduce the Harness as a Python SDK and runtime foundation, explain its design philosophy (middleware chains, skills, sandboxing, config-driven behavior), and provide code examples for embedding the \DeerFlowClient\ in external applications.

frontend/src/content/en/harness · high confidence

New IM channel infrastructure and connectors (Buzz, QQ, WeChat QR login)

The backend now includes a unified channel framework with a base \\Channel\\ class, a \\MessageBus\\ for decoupled pub/sub, and a \\ChannelManager\\ for dispatching inbound messages to agents. This change introduces three new channel integrations: a Buzz (Nostr) connector with pure cryptographic helpers, a QQ Open Platform WebSocket channel, and a WeChat QR login flow for web-based authentication. It also refactors the Feishu channel to use the new base infrastructure and adds a \\ChannelRunPolicy\\ registry to manage per-channel behaviors like recursion limits, credential providers, and fire-and-forget dispatch modes.

deer-flow · high confidence

New Settings dialog with dedicated pages for account, appearance, memory, channels, models, subagents, and notifications

The workspace settings have been reorganized into a unified, single-instance dialog that can be opened from multiple entry points (navigation menu, command palette, deep links) via a shared state store. This dialog includes dedicated pages for Account (profile display, password change for non-SSO users, sign-out), Appearance (theme selection with system/light/dark options and language switching), Channels (connecting and managing external integrations like WeChat), Memory (viewing, editing, importing, and exporting user memory facts and summaries), Models (admin-only management of shared models), Subagents (admin-only creation and configuration of managed subagents), Notifications (browser notification permissions and testing), and About (product information and acknowledgments).

frontend/src/components/workspace/settings · high confidence

New Titanic ADA demo thread added

A new demo thread has been added to the frontend public demos, featuring a conversation where a user asks for interesting findings from the Titanic dataset. The thread includes a system message listing the uploaded \titanic.csv\ file and an AI response that initiates analysis by calling the \read\_file\ tool to examine the dataset structure.

frontend/public/demo/threads/ad76c455-5bf9-4335-8517-fc03834ab828 · high confidence

New UI component library added

The frontend now includes a comprehensive set of new UI components in the \frontend/src/components/ui\ directory, providing a standardized foundation for the user interface. This addition introduces core layout and display elements such as \Alert\, \Badge\, \Breadcrumb\, \Button\, \Card\, \Dialog\, \DropdownMenu\, and \Input\, alongside specialized interactive widgets like \Carousel\, \Command\ (command palette), \ConfettiButton\, \Galaxy\ (visual effect), and \FlickeringGrid\. These components are built using Radix UI primitives and Tailwind CSS, ensuring consistent styling, accessibility, and behavior across the application.

frontend/src/components/ui · high confidence

New agent creation flow with improved error handling and bootstrap chat

The new-agent page now implements a two-step creation process: first validating the agent name (including specific error messages for API disabled, network issues, and backend validation failures), then initiating a bootstrap chat session. It includes retry logic for fetching the newly created agent, prevents form submission during IME composition, and displays a one-time save hint to users.

frontend/src/app/workspace/agents/new · high confidence

New artifact preview, editing, and download capabilities

The frontend now supports inline editing of text artifacts, previewing CSV and TSV files as bounded tables, and downloading run files as a ZIP archive. Artifact content is loaded via a new API layer that handles SHA-256 verification (using ETag headers for non-secure contexts) and range requests for previews. A dedicated viewer route allows markdown and tabular artifacts to be opened in a new window with the app's renderer, while HTML and XML artifacts are served as downloads to prevent script execution. Delimited file parsing is offloaded to a Web Worker to maintain UI responsiveness.

frontend/src/core/artifacts · high confidence

New backend scripts for database migration, safety testing, and e2e replay tooling

This change introduces a suite of new backend scripts to support recent architectural shifts. Operators can now migrate legacy file-based custom agents and managed subagents into the new database-backed storage using \\migrate\_agents\_to\_db.py\\, and migrate legacy global JSON memory facts into per-user Markdown files via \\migrate\_memory\_markdown.py\\. A comprehensive \\migrate\_user\_isolation.py\\ script handles the one-time migration of legacy thread, agent, and skill directories into the new per-user filesystem layout. To support the new TypeSafe risk gate, \\eval\_typesafe\_risk\_gate.py\\ provides a pre-enablement evaluation tool against the real endpoint. For testing and debugging, \\e2e\_safety\_termination\_demo.py\\ demonstrates the safety middleware's behavior, while \\\_autogen\_revision.py\\ simplifies Alembic migration generation by using ephemeral databases. Finally, \\record\_gateway.py\\ and \\run\_replay\_gateway.py\\ provide the infrastructure for deterministic record-and-replay e2e testing.

backend/scripts · high confidence

New blog section with post listing, tagging, and localization

The frontend now includes a dedicated blog area that displays a list of all posts, filters posts by tag, and supports multiple languages. The implementation uses Next.js App Router files to handle dynamic routes for individual posts, the main post list, and tag-based filtering, while leveraging Nextra for MDX rendering and layout. Users can now navigate to the blog, view posts organized by tags, and see content localized according to their preferred language.

frontend/src/app/blog · high confidence

New bookmarks example plugin for saving and searching conversation answers

The \examples/deerflow-extension-bookmarks\ directory now provides a complete, independent plugin example that lets users save the last visible assistant answer from a conversation, then search, rename, read, or delete those bookmarks on a dedicated 'My bookmarks' page accessible via the workspace sidebar. The plugin uses a local SQLite database for per-user persistence (configured via \storage\_path\), exposes a read-only \search\_bookmarks\ model tool for agents, and requires a host with the full-stack plugin contract and \extension-api\ 0.2.3. It includes the Python backend logic, frontend UI assets, and a \ui\_manifest.json\ for static asset registration.

examples/deerflow-extension-bookmarks · high confidence

New built-in tools for background tasks, clarifications, and file management

This change introduces a new \builtins\ module in the harness that exposes several new tools to agents: \list\_background\_tasks\ and \cancel\_background\_task\ for managing long-running MCP tasks, \ask\_clarification\_tool\ for structured human-input cards, \list\_uploaded\_files\ for discovering historical uploads, \present\_file\_tool\ for making files visible in the client, \review\_skill\_package\ for inspecting skill packages, \setup\_agent\ and \update\_agent\ for managing custom agent configurations, and \view\_image\_tool\ for reading images from the sandbox. These tools provide the foundational capabilities for task delegation, user interaction, file handling, and agent customization within the DeerFlow harness.

backend/packages/harness/deerflow/tools/builtins · high confidence

New capabilities catalog and installation management infrastructure

This change introduces the foundational frontend infrastructure for managing plugins and skills, including a new JSON-based catalog (builtin.demo.json) defining integrations like Lark, DingTalk, WeCom, Tencent Docs, and Notion, alongside TypeScript types, React Query hooks for fetching the catalog and installation status, and a static adapter for demo/mock data. Users will benefit from a unified system to view, configure, and select which MCP plugins and skills an agent can use, with support for localized labels and connection validation logic.

frontend/src/core/capabilities · high confidence

New checkpoint benchmarking and analysis tooling

Added a suite of scripts under \backend/scripts/benchmark/checkpoint\ to measure and analyze checkpoint storage and performance. \bench\_tool\_result\_probe.py\ quantifies the storage impact of the \ToolOutputBudgetMiddleware\ by comparing raw versus externalized tool results in SQLite checkpoints. \checkpoint\_bench\_common.py\ provides shared infrastructure for benchmark execution, including child-process control and statistical helpers. \summarize\_channels.py\ and \summarize\_production.py\ process benchmark JSONL outputs to generate paired full/delta performance summaries (medians, ratios, and spike metrics) for both channel-level and production-shaped workloads.

backend/scripts/benchmark/checkpoint · high confidence

New demo thread for DeerFlow deep research

Added a new demo thread that showcases a multi-agent deep research workflow on the bytedance/deer-flow GitHub repository. The entry includes the conversation history (thread.json) where the AI agent uses a 'github-deep-research' skill to perform a four-round investigation, and the resulting outputs: a structured Markdown report (research\_deerflow\_20260201.md) and a styled HTML report (index.html) featuring executive summaries, timelines, and comparative analysis.

frontend/public/demo/threads/fe3f7974-1bcb-4a01-a950-79673baafefd · high confidence

New demo thread for kimi-k2.5 frontend design generation

A new demo thread (c02bb4d5) has been added to showcase the kimi-k2.5 model's ability to generate production-grade frontend interfaces. The thread includes a complete conversation history and the resulting output files (HTML, CSS, and JavaScript) for a 'Pride and Prejudice' landing page, demonstrating the model's use of the 'frontend-design' skill to create a Regency-era themed site with interactive elements.

frontend/public/demo/threads/c02bb4d5-4202-490e-ae8f-ff4864fc0d2e · high confidence

A new demo conversation thread has been added to the frontend public demos, featuring an AI agent researching 'trends and opportunities in 2026'. The thread includes tool calls for web searching and fetching articles, and generates a complete, interactive HTML report titled '2026 Horizons: Trends & Opportunities' with dark mode support and scroll animations.

frontend/public/demo/threads/7cfa5f8f-a2f8-47ad-acbd-da7137baf990 · high confidence

New demo thread showcasing AI-generated skincare landing page

A new demo thread has been added that demonstrates the system's ability to generate a complete, production-grade frontend interface. The example features a minimalist landing page for a fictional skincare brand named "Caren," including the underlying conversation log (thread.json) where the AI agent plans the design, generates structured prompts for image creation, and writes the final HTML/CSS output (index.html). This entry illustrates the end-to-end workflow of combining frontend design skills with image generation capabilities to deliver a polished, responsive web page.

frontend/public/demo/threads/b83fbb2a-4e36-4d82-9de0-7b2a02c2092a · high confidence

New demo: Interactive 3D liquid-glass weather forecast

A new demo thread has been added that showcases the Kimi K2.5 model generating a production-grade, liquid-glass-style weather forecast interface. The demo includes a single HTML file featuring a 3D-tilting weather card, animated background effects for sunny/rainy/snowy states, and interactive controls to switch between weather conditions, demonstrating the model's ability to create distinctive, high-quality frontend designs with complex CSS and JavaScript.

frontend/public/demo/threads/f4125791-0128-402a-8ca9-50e0947557e4 · high confidence

New extension API for host-bound run control, evidence, and plugin contributions

The \deerflow-extension-api\ package introduces a comprehensive set of protocols and data contracts that enable extensions to interact with the host system. Extensions can now control agent runs (start, resume, cancel, wait) using host-bound execution fences, observe task lifecycles and system model calls, and access immutable run evidence (snapshots and events). The API also defines how plugins contribute backend actions, model tools, and frontend modules, including specific handling for structured artifacts and static assets. Additionally, it provides mechanisms for middleware placement, message provenance stamping, and guarded skill mutations, all secured by host-resolved authentication and authorization resolvers.

deerflow-extension-api · high confidence

New extension example demonstrates tool statistics and extension lifecycle

The \examples/deerflow-extension-example\ package now provides a standalone reference implementation for building DeerFlow extensions. It demonstrates five contribution types: middleware, task lifecycle, system-model observer, service, and router. The included middleware specifically tracks tool call outcomes (returned, raised, cancelled) and elapsed time, exposing these aggregated statistics via a new \GET /api/extension-example/stats\ endpoint. The example also illustrates how to manage extension installation, enabling, and disabling through the DeerFlow extension manager.

examples/deerflow-extension-example/tests · high confidence

New extension test fixtures for browser-based plugin previews

Added a new \backend/extension\_test\_fixtures\ package containing synthetic, loopback-only FastAPI applications (\agent\_teams\_gateway\, \bookmark\_plugin\_gateway\, \browser\_asset\_gateway\) and demo extension modules (\demo\_extensions\). These fixtures allow developers to preview and test extension behaviors—such as agent team collaboration, bookmarking, and static asset registration—in a browser environment using real plugin routes and synthetic identity, without requiring the full production Gateway or external language models.

_backend/extension\_test\fixtures · high confidence

New file-based artifact management and preview system

The workspace now features a dedicated artifact system for managing and previewing generated files. Users can view a list of artifacts with file icons and extension details, and open them in a detailed view that supports inline editing for text/code files, HTML previews, and bounded table previews for CSV/TSV files. The system includes a trigger button to open the artifact panel, persists panel state (open/closed, selected file) across navigation using session storage, and allows downloading individual files or archives of multiple artifacts. It also supports installing .skill files for admin users and handles citation source extraction for markdown previews.

frontend/src/components/workspace/artifacts · high confidence

New frontend development and build tooling scripts

The frontend now includes a set of new Node.js scripts in the \scripts\ directory to manage development, builds, and demo content. \dev.mjs\ starts the Next.js development server, defaulting to Webpack to avoid PostCSS worker leaks on macOS while allowing an override via the \DEER\_FLOW\_DEV\_BUNDLER\ environment variable. \measure-route-assets.mjs\ measures and validates the size of JavaScript, CSS, and HTML assets for specific routes against defined budgets, supporting both normal and static website build modes. \save-demo.js\ fetches chat thread history from the backend API and saves it as static JSON files for demo purposes, including associated user data and uploads. \sync-capability-catalog.mjs\ copies and formats the backend's capability catalog into the frontend's demo configuration, ensuring the frontend stays in sync with backend-defined capabilities.

frontend/scripts · high confidence

New frontend extension system with plugin surfaces, mentions, and actions

The frontend now includes a new extension system that allows plugins to register UI surfaces (pages), mention providers for composer mentions, and conversation actions. This system loads extensions from the backend, validates their modules, and mounts them in shadow DOMs. It also supports plugin-specific backend actions and provides a catalog of bundled extensions.

frontend/src/core/extensions · high confidence

New frontend hooks for global keyboard shortcuts and mobile detection

Added two new React hooks to the frontend: \useGlobalShortcuts\ enables registering global keyboard shortcuts that are suppressed when focus is inside input fields (with an exception for the 'k' key to support command palettes), and \useIsMobile\ provides a reactive boolean indicating whether the viewport width is below 768px using \useSyncExternalStore\.

frontend/src/hooks · high confidence

New frontend source scaffolding and developer tooling

The \frontend/src\ directory now contains the initial project scaffolding, including environment variable validation (\env.js\), MDX documentation components (\mdx-components.ts\), a version display module (\version.ts\), and developer configuration for allowing non-localhost access to the dev server (\dev-origins.js\). A comprehensive \AGENTS.md\ file has been added to document the frontend's data flow, state management, and UI rendering patterns.

frontend/src · high confidence

This change introduces a new citation rendering system in the workspace. Users will now see inline citation badges that link to external sources or open a dialog showing the specific RAGFlow knowledge source excerpt (document name, dataset, and text). Additionally, a new 'Citation Sources' panel appears at the bottom of responses, listing all referenced sources with their titles, domains, and citation counts, and allowing users to copy a formatted markdown reference for each source.

frontend/src/components/workspace/citations · high confidence

New landing page sections for DeerFlow 2.0

The landing page now includes dedicated sections to showcase DeerFlow 2.0 capabilities: a Case Studies section displaying public demo threads, a Community section with a GitHub contribution link, a Sandbox section highlighting the AIO Sandbox environment, a Skills section with progressive animations, and a What's New section featuring a bento-grid layout of key features like memory, planning, and multi-model support.

frontend/src/components/landing/sections · high confidence

New landing page with hero, navigation, and blog components

The landing page area now includes a complete set of UI components: a responsive header with navigation links and a GitHub star counter, a hero section featuring animated text and background effects, a mobile navigation drawer, a footer with licensing info, a reusable section component, and a blog post list with metadata and tags. These components collectively form the visual structure of the new landing page.

frontend/src/components/landing · high confidence

New lark-cli-broker sidecar image for secure credential handling

A new Docker image (\docker/lark-cli-broker\) implements 'Pattern B' for the Lark integration, introducing a long-running sidecar that holds \lark-cli\ and per-user credentials. This allows the sandbox to execute commands via a shim over a loopback HTTP interface without ever mounting plaintext app secrets or OAuth tokens into the sandbox filesystem, thereby preventing credential exfiltration by compromised agents. The image supports two modes: \install-shim\ to stage a launcher in a shared volume for the sandbox, and \serve\ to run the broker HTTP server on \127.0.0.1:8788\. It also includes an optional subcommand denylist feature (\DEERFLOW\_LARK\_BROKER\_DENY\_SUBCOMMANDS\) to block specific commands that might expose tokens.

docker/lark-cli-broker · high confidence

New lark-cli-init Docker image for sandbox runtime provisioning

A new Docker image (\docker/lark-cli-init\) has been added to provision the Lark CLI runtime into Kubernetes sandbox pods via an init container and shared emptyDir volume. This image downloads and SHA-256-verifies the official \larksuite/cli\ Linux binaries (amd64 and arm64) at build time, staging them in a layout that matches the existing Gateway writer output. At runtime, the init container copies these binaries to the shared mount point (\/mnt/integrations/lark-cli/runtime\), allowing the sandbox container to access the \lark-cli\ executable without relying on hostPath mounts or downloading binaries at install time. This change is opt-in and controlled by the \LARK\_CLI\_INIT\_IMAGE\ environment variable on the provisioner service.

docker/lark-cli-init · high confidence

New mem0 HTTP memory backend for DeerFlow

DeerFlow now supports mem0 as an external memory backend, allowing agents to use the mem0 Platform API or a self-hosted server for stateless memory storage. This backend supports two modes: middleware (passive memory accumulation) and tool (query-aware semantic recall). Configuration is handled via \backend\_config\ in \config.yaml\, including settings for API keys, base URLs, timeouts, and failure policies (read/write). The implementation includes a synchronous HTTP client, configuration validation, and message filtering logic to ensure only relevant conversation data is sent to mem0. It is designed to be safe for multi-worker deployments as all state management is handled server-side by mem0.

backend/packages/harness/deerflow/agents/memory/backends/mem0 · high confidence

New mock API endpoint for available skills

A new mock API route at \/mock/api/skills\ has been added to the frontend application, providing a static list of available skills. This endpoint returns metadata for eleven distinct capabilities, including deep research, frontend design, image and video generation, music and podcast creation, presentation generation, and deployment tools, allowing the client to discover and configure these features.

frontend/src/app/mock/api/skills · high confidence

New modular authentication system with secure credential handling and Personal Access Tokens

The authentication logic has been restructured into a dedicated module (backend/app/gateway/auth) that introduces several key capabilities. First, it implements a secure first-boot setup where initial admin credentials are written to a restricted file (mode 0600) instead of being logged, preventing secret sprawl. Second, it introduces Personal Access Tokens (PATs) for programmatic API access, scoped to specific thread, run, and project operations, with tokens stored as SHA-256 digests. Third, it adds OIDC SSO support with user provisioning, including domain restrictions and protection against auto-linking to existing local accounts. Fourth, it hardens password security by migrating to a versioned hash format (v2) that avoids bcrypt's 72-byte truncation limit, with automatic migration on login. Finally, it ensures JWT secret persistence across restarts via a shared file and implements distributed login throttling using the database to prevent brute-force attacks across multiple gateway replicas.

backend/app/gateway/auth · high confidence

New project detail page with tabs for chats, documents, instructions, and settings

Users can now view and manage individual projects via a new detail page at /workspace/projects/\[id\]. This page features a tabbed interface allowing users to switch between project threads (chats), a document shelf, project instructions, and project settings. It includes functionality to create new chats scoped to the project, view project status (such as archived), and handles loading and not-found states appropriately.

frontend/src/app/workspace/projects · high confidence

New public skills for academic review, agent onboarding, and data visualization

Users can now leverage three new public skills: the academic-paper-review skill for generating structured, peer-review-style analyses of research papers; the bootstrap skill for conducting a conversational onboarding to generate a personalized SOUL.md defining the AI partner's identity and behavior; and the chart-visualization skill for transforming data into various visual charts (including line, bar, map, and network graphs) via a Node.js script.

skills · high confidence

New run lifecycle management and stream cleanup infrastructure

The runs module now provides core infrastructure for managing agent run lifecycles, including status tracking (pending, running, success, error, timeout, interrupted) and disconnect behavior (cancel or continue). It introduces a robust stream cleanup mechanism that ensures agent streams are properly closed and resources are drained before run-scoped resources are released, handling asynchronous cancellation safely. Additionally, it adds run naming helpers to resolve agent names from configuration for tracing purposes. Also in this area: 26 commits (21 fixes) fixing backend.

backend/packages/harness/deerflow/runtime/runs · medium confidence · unverified

New sandbox benchmarking suite with resource sampling and result summarization

Added a new benchmarking toolset under \backend/scripts/benchmark/sandbox\ to measure sandbox provider performance and resource usage. The suite includes \bench\_provider.py\ for running lifecycle and pressure scenarios (supporting AIO Docker and OpenSandbox providers), \resources.py\ for sampling Docker container CPU and memory usage during benchmarks, and \summarize.py\ for aggregating JSONL benchmark results into statistical tables. The tooling enforces safe practices by rejecting negative idle timeouts and requiring isolated, disposable configurations to prevent interference with production environments.

backend/scripts/benchmark/sandbox · high confidence

New sandbox provisioner, extension examples, and agent guidance size checks

The product now includes a new Kubernetes-based sandbox provisioner service (docker/provisioner/app.py) that dynamically creates and manages per-sandbox Pods and Services, supporting configurable container ports, ClusterIP/NodePort service types, and optional PVC mounts for skills and user data. Additionally, several standalone extension examples are introduced: a Jev context pruning example (deerflow-extension-jev-context), a Jev text classification example (deerflow-extension-jev-classify), and a Jev fetched-content screening example (deerflow-extension-jev-screening), demonstrating how to use the new extension API for middleware and lifecycle hooks. A new script (scripts/check\_agent\_guidance.py) enforces size limits on AGENTS.md instruction chains to prevent excessive context bloat. Finally, a development harness script (scripts/dev\_multi\_instance.py) is added to support running two Gateway instances locally for testing multi-instance scenarios.

python · high confidence

New scripts for dependency checking, version bumping, and Helm chart validation

The scripts directory now includes a suite of new tooling: \check.py\ and \check.sh\ provide cross-platform dependency verification for Node.js, pnpm, uv, and nginx; \bump\_version.sh\ synchronizes version numbers across \pyproject.toml\, \package.json\, and Helm charts; and several \check\chart\\*.sh\ scripts validate Helm chart rendering for sandbox service types, storage paths, and ingress policies. Additionally, \AGENTS.md\ documents the contracts for these scripts, including shell invocation and static analysis targets.

scripts · high confidence

New synthetic benchmark harness for evaluating parent context snapshots

A new manual evaluation script has been added at \backend/scripts/benchmark/context\_snapshot\ to compare a complete, isolated handoff against an opt-in parent-context snapshot. The harness runs eight synthetic JSON/Python tasks with 51 predeclared checks, using a restricted Python exercise profile for grading that strictly distinguishes booleans from numbers (e.g., \false\ is not equal to \0\). It provides CLI commands to run live evaluations against an OpenAI-compatible endpoint or to summarize offline results, recording detailed usage metadata, timing, and artifact correctness while explicitly excluding external datasets, live CI integration, and provider payload logging.

_backend/scripts/benchmark/context\snapshot · high confidence

New synthetic benchmark pilot for scheduled tasks and conversation goals

A new benchmark suite has been added under \backend/scripts/benchmark/scheduled\tasks\ to validate scheduled task execution and conversation goal behaviors using a disposable, local Gateway instance. The suite includes a CLI runner (\\\main\\_.py\) with commands for offline planning, live execution against a loopback Gateway, and read-only rechecking of budget-constrained runs. It utilizes synthetic fixtures (\fixtures.json\) and a constrained tool (\read\_scheduled\_fixture\) to test task scheduling, goal completion, and token budget enforcement without fetching external data or incurring real provider costs outside the disposable pilot. The implementation includes protocol validation, artifact grading, and spend accounting to ensure the scheduled task and goal features function correctly in a controlled, reproducible environment.

_backend/scripts/benchmark/scheduled\tasks · high confidence

New tool system with artifact handles, deferred search, and conversation scheduling

The tools module now provides a comprehensive tool registry and management system. Users can now reference tool outputs via deterministic artifact handles that persist across context compaction, ensuring reliable file and URL references. A new deferred tool search mechanism allows for efficient, bounded discovery of available tools with literal keyword support. The system introduces conversation scheduling capabilities, enabling users to create, update, and manage recurring or one-time tasks directly from the chat interface. Additionally, a new \read\_conversation\ tool allows reading referenced conversations with pagination and continuation support, while \skill\_manage\_tool\ provides a secure, locked interface for creating and evolving custom skills with static security scanning.

backend/packages/harness/deerflow/tools · high confidence

New trash management interface for workspace documents

Users can now access a dedicated trash view at /workspace/trash to manage deleted documents. This new feature allows users to view a paginated list of trashed items, including their origin project and remaining retention period. Users can restore individual documents back to their original project (with conflict handling for missing content) or permanently delete them. An 'Empty trash' option is also available to permanently remove all trashed documents at once, bypassing the retention window. The interface is hidden in static demo mode and includes proper error handling and loading states.

frontend/src/app/workspace/trash, frontend/src/components/workspace/trash, frontend/src/core/trash · high confidence

New unified workspace capabilities center for plugins, skills, and extensions

A new workspace capabilities center has been introduced, consolidating the management of plugins, skills, and extensions into a single, tabbed interface. This new location replaces the previous scattered management paths, providing a dedicated gallery for browsing and installing plugins, a gallery for managing and uploading skills, and a view for handling extensions. The update includes new UI components for displaying capability cards, a plugin icon picker, and specific settings pages for integrations like Lark, streamlining how users discover, configure, and maintain their workspace tools.

frontend/src/components/workspace/capabilities · high confidence

New utility modules for datetime, file handling, JSON, markdown, and UUIDs

This change introduces a set of new helper modules in the frontend core utilities to standardize common operations. The datetime module provides a locale-aware 'time ago' formatter that safely handles invalid timestamps. The file utilities module adds functions to extract file names and extensions, and maps file extensions to language identifiers for syntax highlighting, alongside a list of extensions supported for browser preview. A new markdown utility robustly extracts titles from markdown content, correctly handling leading blank lines and indented headings. Additionally, a JSON utility offers a safe parsing wrapper using best-effort parsing, and a UUID module exposes the v4 UUID generator. Also in this area: 3 commits (1 fix) modifying frontend.

frontend/src/core/utils · medium confidence · unverified

Opt-in task continuity with working notes and searchable history

Agents can now maintain short, model-generated working notes (up to 8 keys, 750 characters each) and search their own task history. The new \task\_note\ tool lets the model save context, decisions, and next steps, with parallel additions safely reserving slots to preserve existing notes. The \history\_search\ tool finds relevant past interactions by keyword, optionally filtering by role (user, assistant, or tool), and returns bounded excerpts with character offsets. \history\_read\ retrieves full source text by ID. These capabilities are opt-in via the \task\_continuity\ configuration and store data in a thread-local SQLite archive, keeping the agent's long-term user memory unaffected. Also in this area: 5 commits (1 fix) modifying backend/packages/harness.

_backend/packages/harness/deerflow/agents/task\continuity · medium confidence · unverified

Pluggable fine-grained authorization framework for tools, skills, and plugins

The system now enforces resource-level authorization across tools, skills, plugins, and sandboxes. A new pluggable provider protocol allows custom authorization backends, with a built-in RBAC provider available for role-based policies. Tool and skill visibility is now filtered at assembly time based on the user's role, and tool execution is gated by authorization checks. Plugin actions, pages, and management routes are also subject to authorization enforcement. Sandbox execution requires explicit authorization, and a new typed carrier ensures async skill activation decisions are handled correctly without falling back to synchronous APIs.

backend/packages/harness/deerflow/authz · high confidence

Pluggable memory backend architecture with Noop template

The memory system now uses a pluggable \MemoryManager\ interface, allowing the underlying storage backend to be swapped by dropping a folder into \backends/\ and setting \manager\_class\ in the config. A \NoopMemoryManager\ is included as a functional empty adapter and template for new backends, enabling users to disable memory storage entirely or integrate custom memory providers without modifying core logic.

backend/packages/harness/deerflow/agents/memory · high confidence

Pluggable memory backend architecture with OpenViking and Honcho support

The memory system now supports pluggable backends, allowing users to swap the underlying memory provider by changing a single configuration line in \config.yaml\ without modifying core code. This change introduces two new optional remote backends: OpenViking (using the official \langchain-openviking\ package) and Honcho (an HTTP-based user-model memory provider with workspace-per-user isolation). The default backend remains DeerMem, and a \noop\ template is provided to help developers create custom backends. Users can now choose between local structured storage, remote OpenViking middleware, or remote Honcho services based on their deployment needs.

backend/packages/harness/deerflow/agents/memory/backends · high confidence

Public case study routes for static demo threads

Users can now access specific showcase case studies via public URLs (e.g., /showcase/\[thread\_id\]). This change introduces a dedicated layout and page component that renders the chat interface for pre-defined demo threads, ensuring proper internationalization and authentication context while returning a 404 for any thread ID not in the static demo list.

frontend/src/app/showcase · high confidence

Redesigned message list with structured conversation navigation and enhanced rendering

The message list component has been rebuilt to support a richer, more structured chat experience. Users can now navigate long conversations using a new conversation outline sidebar that displays chapter-based navigation ticks. Message rendering has been upgraded with a new MarkdownContent component that features smooth, animated streaming text reveals and improved code block handling. The UI now includes dedicated components for displaying human input forms, subtask progress cards with step timelines, and knowledge scope summaries. Additionally, a new markdown-link component enforces a strict protocol allowlist to block unsafe link schemes, and the list supports persistent run duration tracking and token usage summaries.

frontend/src/components/workspace/messages · high confidence

Reproducible benchmark for DeerMem hybrid-v1 capacity eviction policy

A new deterministic evaluation suite has been added to \backend/scripts/benchmark/deermem\_eviction\ to reproduce and verify the DeerMem \hybrid-v1\ capacity eviction policy against the baseline \confidence\ policy. This tool allows for a controlled, offline comparison using a pinned version of the LongMemEval dataset and a blind, versioned grading script (\deterministic-overlap-v1\). It supports running the production \select\_facts\_for\_capacity\ selector at specific capacities (5, 7, and 9) and can execute live QA calls against an OpenAI-compatible provider to measure answer accuracy. The suite ensures reproducibility by validating dataset hashes, config contracts, and prompt versions, and it outputs public, metadata-only reports including paired statistical tests (McNemar) to compare the two policies.

_backend/scripts/benchmark/deermem\eviction · high confidence

Runtime harness introduces dual-mode checkpoint storage and comprehensive lifecycle management

The runtime package now supports a new 'delta' checkpoint mode alongside the existing 'full' mode, using LangGraph's DeltaChannel to store only per-step message changes rather than full snapshots, which reduces storage growth from O(N²) to O(N) in conversation turns. This mode is process-frozen at startup and enforces strict compatibility checks to prevent full-mode processes from reading delta checkpoints (and vice versa), ensuring data integrity during the migration path. The update also introduces a robust run lifecycle system with deferred terminal commits, lease renewal tracking, and safe cancellation draining to prevent orphaned resources. Additionally, it adds per-LLM-call telemetry for detailed token and usage tracking, a new stream bridge with configurable heartbeats and gap detection for reliable event streaming, and strict sanitization for client context inputs to prevent prompt injection.

backend/packages/harness/deerflow/runtime · high confidence

Sandbox subsystem restructured with hardened security and new isolation features

The sandbox subsystem has been reorganized into a modular package with a new AGENTS.md documentation file and dedicated modules for environment policy, acquire serialization, and exceptions. Environment variables are now scrubbed of secrets (keys, tokens, passwords, DSNs) before being passed to sandbox subprocesses to prevent credential leakage. A new authorization gate enforces sandbox execution permissions before reuse. Acquire operations are serialized using a bounded lock-table to prevent concurrency issues. The subsystem now supports cross-instance ownership stores (memory/Redis) for container lifecycle management, and includes new tools for grep and glob operations with bounded results. File operations include read-before-write gates and improved error handling for binary files and truncation.

backend/packages/harness/deerflow/sandbox · high confidence

Scheduled tasks: user-facing controls, run history, and goal outcomes

The frontend now exposes the full user-facing interface for scheduled tasks. Users can manage task states (pause, resume, run now, edit, duplicate, delete) with logic that correctly disables actions based on whether a task is running, queued, or terminal. The interface supports creating and editing tasks with various schedule types (once, cron, interval) and includes a paginated run history view. Additionally, users can see why a chat goal stopped and when it was met, with detailed outcomes and end conditions displayed in the run history. Also in this area: Local image resolution in Markdown artifacts and knowledge citation evidence; Feishu group notifications and refined thread list pagination; Admin user management, disabled-account login messaging, and skill diagnostics.

frontend/src/core/scheduled-tasks · high confidence

Skills system restructured with deferred discovery, request-scoped secrets, and native security scanning

The skills subsystem has been reorganized into a modular package under \backend/packages/harness/deerflow/skills/\, introducing several key capabilities. Skills can now be discovered deferredly via the \describe\_skill\ tool to keep system prompts compact, with a new \SkillCatalog\ and \describe.py\ modules handling intent-based ranking. Request-scoped secrets allow per-request credentials to be passed to skills without entering the prompt or traces, enforced through \SkillActivationMiddleware\ and \bash\_tool\ injection. Security is strengthened by a native \SkillScan\ phase that runs offline before LLM scanning, blocking critical findings, and validating archives against zip bombs, symlinks, and NTFS ADS smuggling. The system also enforces \allowed-tools\ dynamically for slash-activated and in-context skills, projects sandbox views with write isolation, and provides a shared cache reset mechanism for multi-replica Gateway deployments.

backend/packages/harness/deerflow/skills · high confidence

Subagent system overhaul: durable batch execution, acceptance checks, and guardrails

The subagent subsystem has been significantly expanded to support durable batch execution, deterministic acceptance criteria, and enhanced runtime guardrails. Users can now submit and track subagent tasks via a durable batch service with lease-based execution and owner-scoped sandbox authorization. A new acceptance checklist system allows lead agents to define decidable criteria (file existence, JSON validity, test execution) that are verified in code after subagent completion, with results surfaced in the delegation ledger. Runtime behavior includes increased default limits (150 max turns, 30-minute timeout), additive stop-reason reporting for turn/token/loop caps, and improved context management with summarization middleware and step history persistence. The system also introduces isolated loop boundaries, deferred tool promotion, and refined sandbox lifecycle management to prevent resource leaks and ensure proper cleanup across cancellations and timeouts.

backend/packages/harness/deerflow/subagents · high confidence

Subtask cards now persist and display full step history, model, and token usage

Subtask cards now show a complete, ordered timeline of the subagent's assistant turns and tool outputs instead of just the latest message, ensuring the full history survives page reloads. The cards also display the effective model name and cumulative token usage for each subtask. Additionally, guardrail caps (token, turn, or loop limits) are surfaced via a structured \stopReason\ field, allowing the UI to distinguish capped runs from standard completions or failures.

frontend/src/core/tasks · high confidence

Thread management and conversation history overhaul

The frontend's thread handling has been restructured into a dedicated core module, introducing a comprehensive set of capabilities for conversation management. Users can now archive and restore threads, branch conversations from specific assistant turns to create side conversations, and export chat history as Markdown or JSON. The system also supports per-thread composer drafts, allowing users to recover their input if a session is interrupted. Under the hood, message ordering and deduplication have been rewritten to ensure chronological integrity during streaming and context compaction, while a new thread list model and search query builder improve sidebar performance and pagination.

frontend/src/core/threads · high confidence

Unified checkpointer provider with async support and delta-history caching

The checkpointer module now provides a unified factory for both synchronous and asynchronous runtimes, supporting memory, SQLite, and PostgreSQL backends. For PostgreSQL, the async provider uses an AsyncConnectionPool with TCP keepalive to prevent stale connection errors, and both providers support custom PostgreSQL schemas. A new CachedHistorySaver wrapper implements a read-through delta-history cache, significantly improving checkpoint retrieval performance by caching channel writes and composing history from warm ancestors rather than walking the full chain.

backend/packages/harness/deerflow/runtime/checkpointer · high confidence

Unified model factory with declarative reasoning contracts and request admission

The models package now exposes a central \create\_chat\_model\ factory that enforces a declarative reasoning capability contract (mapping-valued \reasoning\ profiles with \unsupported\|optional\|required\ states, effort aliases, and history requirements) while preserving legacy boolean paths. The factory manages per-model request admission via a shared FIFO rate limiter, deep-merges thinking templates (\when\_thinking\_enabled\/\disabled\) without mutating caller-owned mappings, and normalizes vLLM/Qwen thinking switches. It also integrates OAuth billing headers for Claude, handles CLI credential file decoding (UTF-8-sig), and provides provider-specific adapters (MindIE XML tool parsing, vLLM cumulative stream usage, Codex SSE termination and tool strictness, DeepSeek/MiMo reasoning content replay) that ensure multi-turn consistency and prevent API errors from stale or missing provider fields.

backend/packages/harness/deerflow/models · high confidence

Unified persistence layer with database-backed custom agents and Alembic schema management

DeerFlow introduces a unified SQL persistence layer (PostgreSQL and SQLite) that replaces ad-hoc storage with a structured, migration-managed schema. Custom agent definitions can now be stored in the database via a new \SqlAgentStore\, enabling consistent cross-node visibility in multi-instance deployments, while the legacy file-based backend remains the default. The system uses Alembic for schema evolution, featuring a hybrid bootstrap process that handles empty, legacy, and versioned databases safely. Key operational improvements include robust handling of PostgreSQL advisory locks for concurrent schema migrations, SQLite concurrency safeguards (WAL mode, busy timeouts), and resilient upsert patterns for unique-key conflicts in agent and channel connection records.

backend/packages/harness/deerflow/persistence · high confidence

Unified, per-user isolated skill storage with safe singleton lifecycle

The skills storage layer has been refactored into a unified, reflection-based factory that manages a global singleton for public skills and a thread-safe, LRU-cached pool of per-user storage instances for custom skills. This change ensures that custom skills are strictly isolated per user (stored under \\{base\_dir}/users/{user\_id}/skills/custom/\\) while public skills remain globally read-only. The new implementation includes robust lifecycle management: it synchronizes the singleton with configuration reloads, prevents blocking the event loop during archive installations by offloading filesystem work to worker threads, and provides explicit reset functions for hot-reload and testing scenarios. Additionally, legacy global custom skills are now surfaced as read-only \\LEGACY\\ entries for users who have not yet created their own custom skills, ensuring backward compatibility without exposing mutable access to shared resources. Also in this area: Admins can now view YAML load errors for custom skills; Fixes for skill discovery cycles and markdown parsing performance; Fixes for input sanitization, event store cancellation, and skill storage robustness.

backend/packages/harness/deerflow/skills/storage · high confidence

View loaded skill snapshots in message details

Users can now inspect the exact skill snapshots used during a conversation. A new message details panel and menu system allow users to click on skill usage entries to view the full SKILL.md content, including metadata like name, description, and source category (built-in, custom, or integration). The snapshot view safely renders markdown content, preserving external links and images while neutralizing relative paths that lack backing resources, and includes a copy action to export the raw skill content.

frontend/src/components/workspace/message-details, frontend/src/components/workspace/skill-usage · high confidence

WeChat QR login and provider icons added to workspace channels

The workspace channels sidebar now supports WeChat QR login, allowing users to authenticate via a QR code flow with binding completion, and displays dedicated provider icons for WeChat, QQ, Buzz, Telegram, Slack, Discord, GitHub, Feishu, and DingTalk. A new dialog manages runtime configuration for these providers, and a status indicator shows whether proactive scheduled notifications are supported by the connected channel.

frontend/src/components/workspace/channels · high confidence

Workspace UI overhaul with new components and features

The workspace interface has been significantly updated with a suite of new components and features. A new command palette (Cmd+K) has been added for quick navigation and actions. Users can now export conversations as Markdown or JSON. A code editor with syntax highlighting and theme support is available for code-related tasks. The UI now displays context usage percentages and goal status with continuation counters. Agent welcome screens provide better context for custom agents. Gateway offline banners and model load error banners improve error handling and user feedback. Additional features include a flip display animation, copy buttons, and knowledge scope selectors for RAG.

frontend/src/components/workspace · high confidence

Removals

Removal of JSON repair utility functions

The \src/utils\ module has been removed, specifically deleting \src/utils/\_\init\\_.py\ and \src/utils/json\_utils.py\. This eliminates the \repair\_json\_output\ function that previously handled JSON normalization, including stripping markdown code block wrappers (such as \\\json or \\\ts) and using the \json\_repair\ library to fix malformed JSON strings. Users relying on this utility for post-processing LLM outputs will need to implement alternative JSON repair logic or use a different library.

src/utils · high confidence

Removal of legacy LLM module and cached model instances

The legacy \src/llms/llm.py\ module has been removed, eliminating the previous mechanism that cached and instantiated \ChatOpenAI\ models for reasoning, basic, and vision tasks via \conf.yaml\. This change removes the global \reasoning\_llm\, \basic\_llm\, and \vl\_llm\ instances, indicating a shift in how LLM providers are initialized and managed within the application.

src/llms · high confidence

Removal of legacy agent factory and exports

The \src/agents\ module has been removed, deleting the \research\_agent\ and \coder\_agent\ exports and the \create\_agent\ factory function that previously relied on the deprecated \langgraph.prebuilt.create\_react\_agent\. This cleanup eliminates the old agent instantiation logic, aligning with the migration to the newer \langchain.agents.create\_agent\ API used elsewhere in the codebase.

src/agents · high confidence

Removal of legacy configuration module

The \src/config\ package has been completely removed, eliminating the previous static configuration system. This deletes the YAML-based loader, the hardcoded team member definitions (researcher, coder), the agent-to-LLM type mapping, and the \Configuration\ dataclass used for runtime settings. Users relying on these specific configuration structures or environment variable overrides defined in this module will need to adopt the new configuration approach.

src/config · high confidence

Removal of legacy crawler implementation

The legacy crawler module in src/crawler has been completely removed. This deletion eliminates the Jina-based web scraping client, the Readability content extractor, and the Article data model that previously handled HTML-to-markdown conversion and message formatting for LLM consumption.

src/crawler · high confidence

Removal of legacy graph implementation files

The \src/graph\ directory has been cleared of its previous implementation files (\\_\init\\_.py\, \builder.py\, \nodes.py\, and \types.py\). This removes the specific graph construction logic, node definitions (such as coordinator, planner, and reporter), and state types that were previously exported from this module, indicating a structural change to how the agent workflow is defined or integrated.

src/graph · high confidence

Removal of legacy prompt templates and template engine

The \src/prompts\ directory has been completely removed, deleting the Jinja2-based template engine (\template.py\, \\_\init\\_.py\) and all associated Markdown prompt files (\coder.md\, \coordinator.md\, \planner.md\, \reporter.md\, \researcher.md\). This eliminates the previous system for rendering agent instructions via variable substitution, indicating a migration to a different prompt management approach.

src/prompts · high confidence

Removal of legacy tool implementations and module structure

The \src/tools\ directory has been completely removed, eliminating the previous module structure that included \\_\init\\_.py\, \bash\_tool.py\, \crawl.py\, \decorators.py\, \python\_repl.py\, and \search.py\. This change removes the built-in Bash execution, Python REPL, web crawling, and Tavily search capabilities, along with the logging decorators and factory functions that supported them, from this location.

src/tools · high confidence

Removal of standalone workflow runner script

The standalone \src/workflow.py\ module, which previously provided a direct entry point for running the agent workflow with configurable debug logging and iteration limits, has been removed. This change eliminates the ability to execute the workflow directly via this specific script file, likely as part of a broader refactoring to consolidate execution logic or migrate to a different orchestration pattern.

src · high confidence

Architecture

DeerFlow harness package extracted and documented

The DeerFlow backend logic has been reorganized into a standalone \backend/packages/harness/deerflow\ package, separating it from the application layer. This change introduces a comprehensive \AGENTS.md\ guide detailing the request trace context, embedded client usage, sandbox policies, and browser automation. It also includes new implementation files for MCP session scoping, trace context management, and compatibility patches for LangGraph checkpointing, alongside constants and logging configuration to support the new structure.

backend/packages/harness/deerflow · high confidence

Gateway router module reorganization and documentation

The backend gateway routers have been reorganized into a structured module under \backend/app/gateway/routers\. A new \\_\init\\_.py\ file explicitly imports and exposes the individual router modules (including \artifacts\, \assistants\_compat\, \auth\, \browser\, \capabilities\, \channel\_connections\, \channels\, \feedback\, and \github\_webhooks\), and a new \AGENTS.md\ file has been added to document the router contracts and persistence behaviors.

backend/app/gateway/routers · high confidence

Behavioural changes

1 commit (0 fixes) modifying backend/packages/extension-api, deerflow-extension-api, examples

A change to existing behaviour in backend/packages/extension-api, deerflow-extension-api, examples — 1 commit, 7 files: “feat(search): find conversations and jump to matching messages (\#8032)” (refs \#8032).

examples/deerflow-extension-workspace-search, frontend/src/core/search · low confidence · unverified

1 commit (0 fixes) modifying examples

A change to existing behaviour in examples — 1 commit, 33 files: “feat: improve file attachments and add Office artifact previews (\#8009)” (refs \#8009).

examples/deerflow-extension-office-preview · medium confidence · unverified

1 commit (0 fixes) modifying frontend/src/app/workspace/usage, frontend/src/components/workspace/usage, frontend/src/core/usage

A change to existing behaviour in frontend/src/app/workspace/usage, frontend/src/components/workspace/usage, frontend/src/core/usage — 1 commit, 9 files: “feat(frontend): add a token usage dashboard for the console APIs (\#7636)” (refs \#7636).

frontend/src/app/workspace/usage, frontend/src/components/workspace/usage, frontend/src/core/usage · medium confidence · unverified

11 commits (5 fixes) modifying examples/deerflow-extension-agent-teams/deerflow\_extension\_agent\_teams

A change to existing behaviour in examples/deerflow-extension-agent-teams/deerflow\_extension\_agent\_teams — 11 commits (5 fixs), 10 files: “feat(extensions): retrieve retained team history and results (\#6793)”; “feat(runtime): support Queue and Steer during active Web runs (\#7729)”; “fix(extensions): roll back shared state mutations on budget check failure (\#7902)”; and 8 more (refs \#6793, \#7729, \#7902, \#6298, \#6243, …).

_examples/deerflow-extension-agent-teams/deerflow\_extension\_agent\teams · medium confidence · unverified

2 commits (0 fixes) modifying examples/deerflow-extension-knowledge

A change to existing behaviour in examples/deerflow-extension-knowledge — 2 commits, 4 files: “feat(knowledge): decouple scope and read-only catalogs (phase 2) (\#6904)”; “feat(extensions): show package-owned usage in extension details (\#8031)” (refs \#6904, \#8031).

examples/deerflow-extension-knowledge · medium confidence · unverified

2 commits (0 fixes) modifying examples/deerflow-extension-report-sections

A change to existing behaviour in examples/deerflow-extension-report-sections — 2 commits, 4 files: “feat(plugins): add sectioned long-form report writing example (\#7371)”; “feat(extensions): show package-owned usage in extension details (\#8031)” (refs \#7371, \#8031).

examples/deerflow-extension-report-sections · medium confidence · unverified

2 commits (0 fixes) modifying examples/deerflow-extension-retrieval

A change to existing behaviour in examples/deerflow-extension-retrieval — 2 commits, 4 files: “feat(extensions): allow ModelTool plugins to return structured artifacts (\#6861)”; “feat(extensions): show package-owned usage in extension details (\#8031)” (refs \#6861, \#8031).

examples/deerflow-extension-retrieval · medium confidence · unverified

2 commits (1 fix) modifying backend/packages/harness/deerflow/community/specstream

A change to existing behaviour in backend/packages/harness/deerflow/community/specstream — 2 commits (1 fix), 2 files: “fix(web-fetch): stop sending .env.example placeholder keys to providers (\#8206)”; “feat(community): add SpecStream web search and fetch provider (\#7968)” (refs \#8206, \#7968).

backend/packages/harness/deerflow/community/specstream · medium confidence · unverified

2 commits (1 fix) modifying backend/packages/harness/deerflow/reflection

A change to existing behaviour in backend/packages/harness/deerflow/reflection — 2 commits (1 fix), 2 files: “refactor: split backend into harness (deerflow.\) and app (app.\) (\#1131)”; “fix(reflection): reject malformed variable paths before diagnosing them (\#7016)” (refs \#1131, \#7016).

backend/packages/harness/deerflow/reflection · medium confidence · unverified

2 commits (1 fix) modifying backend/packages/harness/deerflow/storage/backends

A change to existing behaviour in backend/packages/harness/deerflow/storage/backends — 2 commits (1 fix), 3 files: “feat(storage): add a content-addressed blob store contract (issue \#4189 item 2) (\#5361)”; “fix(storage): tolerate blob sidecar allocation failures (\#6538)” (refs \#4189, \#5361, \#6538).

backend/packages/harness/deerflow/storage/backends · medium confidence · unverified

3 commits (0 fixes) modifying examples/deerflow-extension-knowledge-center

A change to existing behaviour in examples/deerflow-extension-knowledge-center — 3 commits, 13 files: “docs: turn README into an index and move reference detail to docs/guide (\#8113)”; “feat(extensions): show package-owned usage in extension details (\#8031)”; “feat(knowledge): add optional ingestion and status center (\#7518)” (refs \#8113, \#8031, \#7518).

examples/deerflow-extension-knowledge-center · medium confidence · unverified

3 commits (0 fixes) modifying examples/deerflow-extension-knowledge-platform

A change to existing behaviour in examples/deerflow-extension-knowledge-platform — 3 commits, 8 files: “docs: turn README into an index and move reference detail to docs/guide (\#8113)”; “feat(extensions): show package-owned usage in extension details (\#8031)”; “feat(knowledge): add optional platform connections and hierarchical spaces (phase 3) (\#7417)” (refs \#8113, \#8031, \#7417).

examples/deerflow-extension-knowledge-platform · medium confidence · unverified

3 commits (0 fixes) modifying frontend/src/core/subagent-batches

A change to existing behaviour in frontend/src/core/subagent-batches — 3 commits, 4 files: “feat(subagents): continue requested batch work and schedule explicit prerequisites (\#7839)”; “feat(batch): add browser review for persisted results (\#7006)”; “feat(subagents): add unified capacity and durable batch execution (\#4998)” (refs \#7839, \#7006, \#4998).

frontend/src/core/subagent-batches · medium confidence · unverified

3 commits (1 fix) modifying backend/app/subagent\_batches

A change to existing behaviour in backend/app/subagent\_batches — 3 commits (1 fix), 3 files: “fix(gateway): keep batch cancellation running when the scheduler store fails (\#7971)”; “feat(subagents): continue requested batch work and schedule explicit prerequisites (\#7839)”; “feat(subagents): add unified capacity and durable batch execution (\#4998)” (refs \#7971, \#7839, \#4998).

_backend/app/subagent\batches · medium confidence · unverified

3 commits (1 fix) modifying frontend

A change to existing behaviour in frontend — 3 commits (1 fix), 27 files: “feat(frontend): show a scroll-to-bottom button in the message list (\#8205)”; “fix(web-fetch): stop sending .env.example placeholder keys to providers (\#8206)”; “feat(search): find conversations and jump to matching messages (\#8032)” (refs \#8205, \#8206, \#8032). Also in this area: Added unit tests for code highlighting, animation scheduling, and render activity.

frontend/tests/unit/components/ai-elements · medium confidence · unverified

35 commits (7 fixes) modifying backend/packages/harness/deerflow/extensions

A change to existing behaviour in backend/packages/harness/deerflow/extensions — 35 commits (7 fixs), 14 files: “fix(extensions): publish a snapshot restore atomically (\#6366)”; “feature(skills): keep allowed-tools as compatibility metadata (\#6935)”; “feat(extensions): let an out-of-tree extension observe what the agent did (\#4863)”; and 32 more (refs \#6366, \#6935, \#4863, \#6920, \#7831, …).

backend/packages/harness/deerflow/extensions · medium confidence · unverified

4 commits (0 fixes) modifying examples/deerflow-extension-example/deerflow\_extension\_example

A change to existing behaviour in examples/deerflow-extension-example/deerflow\_extension\_example — 4 commits, 2 files: “feat(extensions): let an out-of-tree extension observe what the agent did (\#4863)”; “feat(extensions): show package-owned usage in extension details (\#8031)”; “feat(extensions): add gateway contribution points and packaged extension management (\#4780)”; and 1 more (refs \#4863, \#8031, \#4780, \#6582).

_examples/deerflow-extension-example/deerflow\_extension\example · medium confidence · unverified

4 commits (1 fix) modifying backend/packages/harness/deerflow/agents/memory/backends/noop

A change to existing behaviour in backend/packages/harness/deerflow/agents/memory/backends/noop — 4 commits (1 fix), 3 files: “\[feat\] memory: pluggable MemoryManager interface for backend onboarding (\#4326)”; “fix(memory): flush memory queue on graceful shutdown to prevent loss (\#4181)”; “feat(memory): pluggable memory abstraction with self-contained DeerMem backend (\#4122)”; and 1 more (refs \#4326, \#4181, \#4122, \#5251).

backend/packages/harness/deerflow/agents/memory/backends/noop · medium confidence · unverified

5 commits (1 fix) modifying backend/packages/harness/deerflow/knowledge

A change to existing behaviour in backend/packages/harness/deerflow/knowledge — 5 commits (1 fix), 4 files: “feat(knowledge): unify read-only retrieval and source contracts (phase 1) (\#6716)”; “feat(knowledge): add independent Wiki and entity relation retrieval tools (\#7171)”; “feat(weknora): allow opt-in shared retrieval for authenticated users (\#7944)”; and 2 more (refs \#6716, \#7171, \#7944, \#6904, \#7942).

backend/packages/harness/deerflow/knowledge · medium confidence · unverified

5 commits (1 fix) modifying examples/deerflow-extension-knowledge-management

A change to existing behaviour in examples/deerflow-extension-knowledge-management — 5 commits (1 fix), 6 files: “docs: turn README into an index and move reference detail to docs/guide (\#8113)”; “fix(knowledge): accept case-insensitive upload media types (\#7397)”; “feat(extensions): show package-owned usage in extension details (\#8031)”; and 2 more (refs \#8113, \#7397, \#8031, \#7417, \#7293).

examples/deerflow-extension-knowledge-management · medium confidence · unverified

6 commits (0 fixes) modifying examples/deerflow-extension-weknora

A change to existing behaviour in examples/deerflow-extension-weknora — 6 commits, 12 files: “feat(knowledge): add independent Wiki and entity relation retrieval tools (\#7171)”; “docs: turn README into an index and move reference detail to docs/guide (\#8113)”; “feat(weknora): allow opt-in shared retrieval for authenticated users (\#7944)”; and 3 more (refs \#7171, \#8113, \#7944, \#7707, \#8031, …).

examples/deerflow-extension-weknora · medium confidence · unverified

7 commits (3 fixes) modifying backend/packages/harness/deerflow/storage

A change to existing behaviour in backend/packages/harness/deerflow/storage — 7 commits (3 fixs), 3 files: “fix(artifacts): authorize shared image reads and offload MIME lookup (\#7604)”; “docs: turn README into an index and move reference detail to docs/guide (\#8113)”; “feat(storage): add a content-addressed blob store contract (issue \#4189 item 2) (\#5361)”; and 4 more (refs \#7604, \#8113, \#4189, \#5361, \#6159, …).

backend/packages/harness/deerflow/storage · medium confidence · unverified

7 commits (3 fixes) modifying frontend/src/app/\[lang\]

A change to existing behaviour in frontend/src/app/\[lang\] — 7 commits (3 fixs), 2 files: “feat: Add metadata and descriptions to various documentation pages in Chinese”; “perf(frontend): bound delivery, bundles, and long-running UI work (\#4622)”; “fix(frontend): make docs search work on desktop and mobile (\#6715)”; and 4 more (refs \#4622, \#6715, \#1962, \#1767, \#5275, …).

frontend/src/app/\[lang\] · medium confidence · unverified

7 commits (3 fixes) modifying frontend/src/content/en/harness/subagents, frontend/src/content/zh/harness/subagents

A change to existing behaviour in frontend/src/content/en/harness/subagents, frontend/src/content/zh/harness/subagents — 7 commits (3 fixs), 24 files: “fix(subagents): report model output length caps (\#7355)”; “feature(skills): keep allowed-tools as compatibility metadata (\#6935)”; “docs(subagents): restructure the subagent docs into an eleven-chapter user manual (\#5761)”; and 4 more (refs \#7355, \#6935, \#5761, \#7792, \#6058, …).

frontend/src/content/en/harness/subagents, frontend/src/content/zh/harness/subagents · medium confidence · unverified

8 commits (1 fix) modifying frontend/src/content/zh/harness/extensions

A change to existing behaviour in frontend/src/content/zh/harness/extensions — 8 commits (1 fix), 12 files: “feat(extensions): add example guide and packaging checks (\#6755)”; “feature(skills): keep allowed-tools as compatibility metadata (\#6935)”; “fix(extensions): hand compaction observers the live task store and name the task in CompactionEvent (\#7831)”; and 5 more (refs \#6755, \#6935, \#7831, \#7603, \#5775, …).

frontend/src/content/zh/harness/extensions · medium confidence · unverified

8 commits (1 fix) modifying frontend/src/content/zh/tutorials

A change to existing behaviour in frontend/src/content/zh/tutorials — 8 commits (1 fix), 6 files: “feat(memory): add scoped fact lookup by ID (\#6443)”; “fix the lint errors in frontend”; “feat: Add metadata and descriptions to various documentation pages in Chinese”; and 5 more (refs \#6443, \#5468, \#5843, \#4023, \#7922).

frontend/src/content/zh/tutorials · medium confidence · unverified

Account-scoped preferences sync and per-thread model overrides

Settings are now persisted per account and synced across browsers via a backend API, replacing the previous single-user local storage approach. Users will see their notification preferences, display modes, and model selections synchronized across devices. Additionally, model selection is now remembered independently for each chat thread, allowing different models to be used in different conversations without affecting the global default.

frontend/src/core/settings · high confidence

Agents UI is now gated by the agents\_api feature flag

The Agents workspace page now checks the \agents\_api\ feature flag before rendering. If the feature is disabled or still loading, users see a dedicated "feature disabled" message or a loading state instead of the Agent Gallery. This ensures the Agents UI is only accessible when the underlying API support is enabled.

frontend/src/app/workspace/agents · high confidence

Enforce deployment-wide E2B sandbox capacity limits via Redis

The E2B sandbox capacity management has been refactored to use a Redis-backed ledger, ensuring that the total number of active sandbox reservations is tracked and enforced across the entire deployment rather than per-instance. This change introduces a new capacity module that utilizes atomic Redis operations to manage hard limits, preventing the system from exceeding configured capacity thresholds even under concurrent load. Users will benefit from more reliable resource management and consistent capacity enforcement across all sandbox instances.

_backend/packages/harness/deerflow/community/e2b\sandbox/capacity · high confidence

The frontend library now includes utilities to correctly handle Input Method Editor (IME) composition states, preventing premature submission or action during text composition (specifically addressing Enter key behavior in Safari and other browsers). Additionally, shared utility functions for CSS class merging and specific styling classes for external links (with and without underlines) have been added to standardize link appearance across the application.

frontend/src/lib · high confidence

Improved voice transcript assembly with language-aware spacing

The voice input module now uses a new \speech-recognition.ts\ core to assemble transcript segments, introducing logic that intelligently inserts spaces between words when joining results from providers that trim final transcripts. This prevents words from gluing together in space-delimited languages (like English) while preserving the correct formatting for scripts that do not use spaces (like Chinese or Japanese). The implementation also includes robust error handling and language normalization to ensure consistent behavior across different browser environments.

frontend/src/core/voice-input · high confidence

Interactive first-boot setup replaces automatic admin creation

The setup page now requires users to manually create the initial administrator account during first boot, replacing the previous behavior where an admin account was created automatically. This new interactive flow handles both the initial admin creation and subsequent password changes for authenticated users who need setup, while also improving resilience against service timeouts by allowing retries when the system status is unavailable.

frontend/src/app/(auth)/setup · high confidence

Introduce agents API client, React Query hooks, and feature-gate caching

The frontend now includes a dedicated API layer for managing agents (CRUD operations and name availability checks) along with React Query hooks to consume them. To prevent UI instability when the backend feature flag endpoint is unavailable, a local storage cache is introduced to persist the last known state of the \agents\_api\ feature flag, ensuring the agents interface remains hidden during outages rather than failing open.

frontend/src/core/agents · high confidence

Introduce backend-driven suggestions configuration and placeholder detection

The frontend now fetches a suggestions configuration from the backend to determine whether suggestions are enabled and how many follow-up suggestions to display, falling back to a default of 3 if the backend endpoint is unavailable. A new React Query hook manages this configuration state, and a utility function has been added to detect unreplaced placeholders in suggestion template strings, supporting the localization of prompt templates.

frontend/src/core/suggestions · high confidence

Introduce model favorites and refined reasoning capabilities

Users can now mark specific models as favorites, which are persisted in local storage and displayed prominently in the model selection list. The model selection interface also benefits from improved reasoning support, allowing the system to correctly map and resolve reasoning effort levels (such as minimal, low, medium, high) based on the specific model's capabilities and provider contracts. Additionally, the model loading process has been stabilized to provide clearer feedback when gateway errors occur, and the system now supports a static website demo mode that gracefully handles model loading without a backend.

frontend/src/core/models · high confidence

Introduces abstract user repository interface and case-insensitive email handling

This change adds a new abstract base class for user data storage operations, defining the contract for user repository implementations. It also introduces case-insensitive email handling by normalizing emails to lowercase during creation and lookup, ensuring that accounts are uniquely identified regardless of case variations. Additionally, the first admin creation process is made atomic to prevent race conditions during initial setup.

backend/app/gateway/auth/repositories · high confidence

Jina web fetch client gains bounded retries, response size limits, and admission control

The Jina AI web fetch tool now supports configurable bounded retries (with a total time budget and respect for server Retry-After headers), an opt-in maximum response byte limit to prevent excessive memory usage, and process-local request admission to throttle concurrent calls. The underlying client has been refactored from synchronous requests to async httpx, and the readability extraction is now wrapped in a thread to avoid blocking the event loop. These changes improve reliability and resource control for web fetching operations. Also in this area: 5 commits (1 fix) modifying backend/packages/harness; IM channel shutdown and streaming fixes.

_backend/packages/harness/deerflow/community/jina\ai · medium confidence · unverified

Lead agent module relocated to harness package

The lead agent implementation has been moved from the main application source to the new harness package structure. The \make\_lead\_agent\ factory function is now exposed via \backend/packages/harness/deerflow/agents/lead\_agent\, while the main application entry point has been relocated to \backend/app\.

_backend/app, backend/packages/harness/deerflow/agents/lead\agent · high confidence

Migrate Tavily tools to async client with domain filtering and credential handling

The Tavily search and web-fetch tools have been rewritten to use the asynchronous \AsyncTavilyClient\, ensuring proper connection lifecycle management by closing clients after each use. Search results can now be restricted to specific sources using \include\_domains\ and \exclude\_domains\ configuration options, with inclusion explicitly set to filter mode. Additionally, the web-fetch tool now correctly uses \web\_fetch\ credentials for extraction and safely handles responses that may lack a page title by falling back to the URL. Also in this area: 5 commits (1 fix) modifying backend/packages/harness; You.com web search provider added; sandbox env resolution and credential redaction fixed.

backend/packages/harness/deerflow/community/tavily · medium confidence · unverified

New centralized API client with CSRF protection and robust stream reconnection

The frontend now uses a new \api-client.ts\ module to manage communication with the backend. This client automatically injects CSRF tokens for state-changing requests and handles authentication redirects. It introduces resilient stream reconnection logic that detects gaps in the event stream, recovers durable state, and restores user input to prevent UI hangs. Additionally, it sanitizes unsupported LangGraph stream modes to ensure compatibility and provides a static-response layer for read-only demo environments.

frontend/src/core/api · high confidence

New message grouping, token usage, and UI stability logic in the frontend

The \frontend/src/core/messages\ module has been restructured into dedicated files to improve how the chat UI processes and displays messages. \utils.ts\ now defines the \MessageGroup\ types and grouping logic, ensuring orphan tool messages are kept visible and reasoning content is not rendered twice. \derived-state.ts\ introduces stable message group derivation to prevent unnecessary UI re-renders during streaming. \usage.ts\ and \usage-model.ts\ handle token usage extraction, accumulation, and attribution for debug and per-turn views. \run-duration.ts\ calculates and formats run durations, while \artifact-archive.ts\ and \workspace-change-anchor.ts\ correctly anchor run-specific UI elements to the last relevant group. \human-input.ts\ adds support for structured human input forms, and \tool-detail-preview.ts\ provides bounded serialization for tool details.

frontend/src/core/messages · high confidence

Redesigned login and authentication callback flows with SSO and session persistence

The login experience has been rebuilt to support multiple authentication methods and improved security. Users can now sign in via OIDC SSO providers, which are dynamically fetched and displayed alongside traditional email/password forms. A new 'Keep me signed in' option allows users to persist their session across browser restarts. The login page also handles initial system setup states, preventing registration until an admin completes the first-boot setup. Additionally, a new authentication callback page securely validates the post-login redirect path to prevent open-redirect vulnerabilities, ensuring users are sent to a safe destination after SSO or local authentication.

frontend/src/app/(auth)/login · high confidence

Unified Nginx proxy configuration for Docker and local development

The Docker Nginx setup now uses a single, unified configuration structure that supports both containerized and local development environments. The new \nginx.conf\ is optimized for Docker, resolving upstream service names at request time to handle container restarts and using \/tmp\ for the PID file to avoid permission issues. The \nginx.local.conf\ mirrors this for local \make dev\ runs, binding to \127.0.0.1\ and using local log paths. Both configurations enforce 600-second timeouts for long-running API requests (such as chat prompts and skill installations), disable buffering for streaming responses, and correctly preserve the \X-Forwarded-Proto\ header to ensure authentication and CORS checks work correctly when the proxy is behind another TLS-terminating reverse proxy.

docker/nginx · high confidence

Unified authentication context and hardened session handling

The frontend now uses a centralized \AuthProvider\ to manage user state, replacing previous scattered logic with a single source of truth for authentication. This change introduces a robust logout mechanism that performs a hard navigation to clear all client-side state when the backend is unreachable, preventing stale sessions. It also adds a "Keep me signed in" feature that persists login preferences in local storage, and implements strict validation for the post-login redirect path to prevent open-redirect vulnerabilities. Additionally, the system now supports an "auth-disabled" mode for local development and static website demos, automatically injecting a default admin user when authentication is bypassed. Also in this area: 5 commits (2 fixes) modifying frontend; Artifact drafts now persist across navigation and account changes; Admin user management, disabled-account login messaging, and skill diagnostics.

frontend/src/core/auth · medium confidence · unverified

Updated mock model list and added MCP configuration endpoint

The mock API now serves an updated list of available models, including DeepSeek V4, GPT-5, Gemini 3 Pro, and Doubao Seed 1.8, replacing previous entries. Additionally, a new mock endpoint for MCP (Model Context Protocol) server configuration has been introduced, providing predefined settings for servers like 'mcp-github-trending', 'context-7', and 'feishu-importer'.

frontend/src/app/mock/api/models · high confidence

Workspace layout and sidebar state persistence

The workspace now persists the sidebar's open/closed state across page navigations by reading it from a cookie, and introduces a global command palette accessible via keyboard shortcuts. Additionally, the layout ensures that gateway offline and model loading errors are surfaced as banners within the workspace content area.

frontend/src/app/workspace · high confidence

Workspace layout and sidebar state persistence

The workspace now persists the sidebar's open/closed state across page navigations by reading it from a cookie, and introduces a global command palette accessible via keyboard shortcuts. Additionally, the layout ensures that gateway offline and model loading errors are surfaced as banners within the workspace content area. Also in this area: Admin user management, disabled-account login messaging, and skill diagnostics.

frontend/src/app/(auth) · high confidence

Fixes

12 commits (9 fixes) fixing backend/packages/harness/deerflow/agents/memory/backends/honcho

A fix in backend/packages/harness/deerflow/agents/memory/backends/honcho — 12 commits (9 fixs), 5 files: “fix(memory): validate Honcho's allow\_insecure\_http as a boolean (\#5887)”; “docs(memory): document the Honcho backend (\#4822)”; “fix(memory): report malformed backend\_config values by key name (\#5555)”; and 9 more (refs \#5887, \#4822, \#5555, \#7890, \#4730, …).

backend/packages/harness/deerflow/agents/memory/backends/honcho · medium confidence · unverified

26 commits (21 fixes) fixing backend

A fix in backend — 26 commits (21 fixs), 86 files: “fix(wecom): treat "@bot /new" in group chats as a command (\#8118)”; “fix(subagents): keep a steered subagent report in the parent snapshot (\#8167)”; “fix(subagents): apply tool policies to middleware-declared tools (\#8136)”; and 23 more (refs \#8118, \#8167, \#8136, \#8162, \#8132, …). Also in this area: 5 commits (1 fix) modifying backend/packages/harness.

backend/packages/harness/deerflow/approvals · medium confidence · unverified

3 commits (2 fixes) fixing backend/packages/harness/deerflow/skills/mutations

A fix in backend/packages/harness/deerflow/skills/mutations — 3 commits (2 fixs), 13 files: “fix(skills): keep a failed discard from replacing the publish outcome (\#7586)”; “fix(persistence): normalize non-finite floats before every JSON column write (\#7733)”; “feat(skills): add guarded evolution host APIs (\#5645)” (refs \#7586, \#7733, \#5645).

backend/packages/harness/deerflow/skills/mutations · medium confidence · unverified

4 commits (4 fixes) fixing frontend/src/components/docs

A fix in frontend/src/components/docs — 4 commits (4 fixs), 6 files: “fix: preserve locale in documentation links (\#3717)”; “fix(frontend): make docs search work on desktop and mobile (\#6715)”; “fix: localize Chinese docs links (\#5275)”; and 1 more (refs \#3717, \#6715, \#5275, \#4330).

frontend/src/components/docs · medium confidence · unverified

5 commits (3 fixes) fixing backend/packages/harness/deerflow/community/browser\_automation

A fix in backend/packages/harness/deerflow/community/browser\_automation — 5 commits (3 fixs), 3 files: “fix(browser): preserve the browser context after login popups close (\#7674)”; “docs: turn README into an index and move reference detail to docs/guide (\#8113)”; “fix(browser): pin browser connections to the SSRF-vetted addresses (\#6201)”; and 2 more (refs \#7674, \#8113, \#6201, \#6301, \#4187).

_backend/packages/harness/deerflow/community/browser\automation · medium confidence · unverified

8 commits (7 fixes) fixing backend/packages/harness/deerflow/community/crawl4ai

A fix in backend/packages/harness/deerflow/community/crawl4ai — 8 commits (7 fixs), 3 files: “fix(web\_fetch): add SSRF guard for self-hosted providers (\#3942)”; “feat(community): add Crawl4AI web\_fetch provider (\#3821)”; “fix(community): Fail closed on delegated fetch backends to close SSRF gap (\#6531)”; and 5 more (refs \#3942, \#3821, \#6531, \#6140, \#7981, …).

backend/packages/harness/deerflow/community/crawl4ai · medium confidence · unverified

83 commits (71 fixes) fixing backend/packages/harness/deerflow/utils

A fix in backend/packages/harness/deerflow/utils — 83 commits (71 fixs), 23 files: “feat: add composer input polishing (\#3986)”; “fix(subagents): keep a steered subagent report in the parent snapshot (\#8167)”; “fix(uploads): exclude fenced code from document outlines (\#5281)”; and 80 more (refs \#3986, \#8167, \#5281, \#4589, \#7295, …).

backend/packages/harness/deerflow/utils · medium confidence · unverified

Centralize community provider utilities and harden URL safety

This change introduces several shared modules in the community package to consolidate logic previously duplicated across providers and to improve security. It adds a single owner for retrieval provider credentials (\\provider\_credentials.py\\) to standardize API key unwrapping, redaction, and base URL validation, preventing credential leaks. It centralizes \\max\_results\\ coercion (\\search\_max\_results.py\\) and time-range mappings (\\search\_time\_range.py\\) for bundled search providers. Crucially, it adds a comprehensive URL safety module (\\url\_safety.py\\) that screens public result URLs, resolves hostnames for SSRF screening, and validates delegated backend URLs to block private or loopback addresses. Finally, it provides a shared warm-pool lifecycle mixin (\\warm\_pool\_lifecycle.py\\) for sandbox providers, using monotonic clocks for idle timeout checks to ensure reliable resource cleanup.

backend/packages/harness/deerflow/community · high confidence

Hardened markdown rendering with security sanitization and crash prevention

The Streamdown rendering pipeline now includes robust safeguards against rendering crashes and security vulnerabilities. It prevents stack-overflow crashes caused by deeply nested lists and blockquotes by capping their indentation levels, and ensures math rendering works correctly by normalizing LaTeX delimiters. Additionally, the pipeline enforces strict HTML sanitization to block malicious scripts and DOM clobbering attacks, while correctly handling fenced code blocks and Mermaid diagrams to preserve content integrity.

frontend/src/core/streamdown · high confidence

Local sandbox provider now supports per-thread isolation and secure path mapping

The local sandbox provider has been refactored to replace the previous process-wide singleton with a per-thread sandbox model, ensuring that user data, uploads, and workspace paths are correctly scoped to individual threads and users. This change introduces secure path traversal in directory listings to prevent symlink escapes, enforces custom agent skill allowlists and per-user skill isolation, and ensures that the provider honors the sandbox environment configuration and mount contracts at the API boundary. Additionally, it fixes issues with stale agent skill views when host bash is allowed and ensures that missing mount host paths are treated as errors rather than silently failing.

backend/packages/harness/deerflow/sandbox/local · high confidence

Prevent Goal re-entry after loop hard stops

The system now correctly respects the native loop hard stop when a Goal remains unmet, preventing a hidden continuation turn that previously occurred after the loop guard capped execution. This ensures that the Goal status remains active with a 'loop\_capped' stand-down reason rather than triggering an extra, unnecessary model call, resulting in more predictable run behavior and reduced resource usage.

_backend/scripts/benchmark/goal\_loop\stop · high confidence

The uploads module has been refactored to enforce strict security and reliability standards. It now rejects symlinked upload destinations to prevent path traversal attacks and validates thread IDs to ensure proper isolation. Filename handling is hardened against NUL characters, Windows reserved names, and case-variant collisions, while ensuring deduplicated names stay within the 255-byte limit. The system also safely handles concurrent uploads by skipping files that vanish mid-scan and keeping in-flight staging files out of startup sweeps, ensuring a consistent user experience across different operating systems.

backend/packages/harness/deerflow/uploads · high confidence

Skill review gate: stricter validation, secure scanning, and robust resource reference resolution

The skill review process now enforces stricter metadata validation by requiring the 'optional' flag in 'required-secrets' to be a boolean, preventing invalid configurations from passing review. File scanning has been hardened to handle binary assets via base64 encoding and to prevent file overwrites during snapshot extraction, ensuring all files (including binaries and scripts) are scanned while deliberately excluding eval fixture SKILL.md files. Resource reference resolution has been improved to correctly strip trailing sentence punctuation and handle section anchors (fragments) in links and code spans, ensuring that references with '\#' characters are resolved accurately against the actual file set rather than being misinterpreted as section links.

backend/packages/harness/deerflow/skills/review · high confidence

Test coverage

1 commit adding/updating tests in frontend/tests/unit/core/search; 1 commit adding/updating tests in frontend/tests/unit/core/usage; 2 commits adding/updating tests in frontend/tests/unit/components/docs; 2 commits adding/updating tests in frontend/tests/unit/core/notification; 21 commits adding/updating tests in frontend/tests/unit/core/auth; 3 commits adding/updating tests in frontend/tests/unit/core/subagent-batches; Added E2E tests for artifact viewer access and auth setup recovery; Added Playwright E2E test infrastructure with shared mock API utilities; Added Playwright end-to-end tests for real-backend and record workflows; Added benchmark script for skill export performance; Added multi-process concurrency benchmark for Postgres claim validation; Added strict event-loop blocking I/O regression tests; Added test coverage for skills execution and export behaviors; Added test helpers for scheduled tasks and UI readability; Added tests for memory import normalization and stale-read protection; Added tests for scheduled task detail and form dialogs; Added trace-based behavioural tests for DeerFlow using Monocle Test Tools; Added unit and DOM tests for frontend components and API routes; Added unit tests for Lark integration API client; Added unit tests for MCP configuration API, hooks, icon handling, and definition parsing; Added unit tests for Project Documents and Threads sections; Added unit tests for Streamdown markdown processing; Added unit tests for WeChat QR login and channel connection flows; Added unit tests for agent API, feature flags, and background tasks; Added unit tests for artifact core logic; Added unit tests for background task API and polling logic; Added unit tests for channel provider icons and scheduled update notifications; Added unit tests for citation link rendering and source evidence panels; Added unit tests for citation source extraction and knowledge source validation; Added unit tests for clipboard fallback, reasoning trigger, and streamdown sanitization; Added unit tests for code highlighting, animation scheduling, and render activity; Added unit tests for conversation references, subagent batch execution, and feature capability APIs; Added unit tests for core message handling and sidecar conversation logic; Added unit tests for documentation content integrity; Added unit tests for file utility and markdown parsing functions; Added unit tests for frontend API client and streaming logic; Added unit tests for frontend build scripts and dependency security; Added unit tests for frontend extension system; Added unit tests for global shortcuts and mobile viewport hooks; Added unit tests for i18n context and translation loading; Added unit tests for knowledge scope management and RAGFlow citation provenance; Added unit tests for model API, favorites, and reasoning capabilities; Added unit tests for project document and trash management features; Added unit tests for scheduled tasks core logic; Added unit tests for settings persistence, synchronization, and SSR hydration; Added unit tests for skill usage inspection and message details menu interactions; Added unit tests for subtask lifecycle, rendering, and API logic; Added unit tests for suggestion template placeholder detection; Added unit tests for the RememberSessionOption component; Added unit tests for the agent settings dialog and related components; Added unit tests for the skills module; Added unit tests for thread core logic; Added unit tests for upload API, validation, and file handling; Added unit tests for voice input speech recognition helpers; Added unit tests for workspace artifact components; Added unit tests for workspace capabilities components; Added unit tests for workspace changes API and summary logic; Added unit tests for workspace message components; Expanded test coverage for backend components; Playwright E2E test suite for agents, artifacts, and settings.

Dependencies

DeerFlow 2.2.0-dev: New modular backend architecture and dependency updates

The backend is restructured into a modular workspace with a new \deerflow-harness\ package (version 2.1.0) and a \deerflow-extension-api\ (version 0.2.4) to support a plugin-based extension system. This update upgrades core dependencies to LangGraph 1.x and LangChain 1.x, and introduces optional extras for sandbox providers (E2B, Tenki, OpenSandbox), observability (Monocle), and browser control. The frontend is upgraded to Next.js 16.3.3 and React 19, while the legacy \lite-deep-researcher\ project is removed.

(dependencies) · high confidence

Housekeeping

New Checkpoints documentation manual added; Release 2.1.0-rc0 and documentation updates.

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

How this codebase got here

Score

  • CAI 42 → 46 (+4.3)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 64 → 63 (-0.6)
  • Architecture 86 → 88 (+1.8)
  • Maturity 80 → 82 (+1.7)
  • Readiness 24 → 33 (+8.7)
  • Security 73 → 73 (+0.6)
  • Domain Modelling 100 → 100 (+0.0)
  • Accessibility 46 → 47 (+1.3)
  • Performance 60 → 60 (+0.0)

Resolved (190)

  • AioSandbox._run_bash_exec (cyclomatic 29) (backend/packages/harness/deerflow/community/aio_sandbox/aio_sandbox.py)
  • Ambiguous distinction between 'get' and 'wait'. Both return an AgentRun. 'get' likely returns the current state immediately, while 'wait' blocks until completion or timeout. However, without clear documentation or distinct return types (e.g., Optional[AgentRun] vs AgentRun), the operational difference is subtle and could be confusing. More critically, 'get' might return a completed run, making 'wait' redundant if the run is already done.
  • Change-coupling hub: en-US.ts → memory-settings-page.tsx, settings-dialog.tsx, api.ts (frontend/src/core/i18n/locales/en-US.ts)
  • Change-coupling hub: types.ts → memory-settings-page.tsx, settings-dialog.tsx, api.ts (frontend/src/core/i18n/locales/types.ts)
  • Change-coupling hub: zh-CN.ts → memory-settings-page.tsx, settings-dialog.tsx, welcome.tsx, api.ts (frontend/src/core/i18n/locales/zh-CN.ts)
  • CodexChatModel._call_codex_api (cognitive 17) (backend/packages/harness/deerflow/models/openai_codex_provider.py)
  • CodexChatModel._stream_response (cognitive 38) (backend/packages/harness/deerflow/models/openai_codex_provider.py)
  • CodexChatModel._stream_response (cyclomatic 26) (backend/packages/harness/deerflow/models/openai_codex_provider.py)
  • Documentation: written for insiders (examples/deerflow-extension-jev-context/README.md)
  • Duplicate method name 'list_changed_runs' on two different reader interfaces (RunEvidenceReader and CompletedRunEvidenceReader) that likely serve different purposes (active runs vs completed runs). While the interfaces are distinct, the identical method name on conceptually similar 'Reader' types can cause confusion about which reader to use for which domain.
  • Duplicated block (10 lines × 2) (backend/app/channels/dingtalk.py)
  • Duplicated block (10 lines × 2) (skills/public/data-analysis/scripts/analyze.py)
  • Duplicated block (11 lines × 2) (backend/packages/harness/deerflow/agents/memory/backends/deermem/deermem/core/updater.py)
  • Duplicated block (11 lines × 2) (backend/packages/harness/deerflow/agents/memory/manager.py)
  • Duplicated block (11 lines × 2) (backend/packages/harness/deerflow/community/infoquest/infoquest_client.py)
  • Duplicated block (11 lines × 2) (backend/packages/harness/deerflow/runtime/checkpointer/cached_saver.py)
  • Duplicated block (11–13 lines × 2) (backend/packages/harness/deerflow/community/aio_sandbox/aio_sandbox_provider.py)
  • Duplicated block (12 lines × 2) (backend/packages/harness/deerflow/community/sofya/tools.py)
  • Duplicated block (14 lines × 2) (backend/packages/harness/deerflow/agents/memory/backends/deermem/deermem/core/prompt.py)
  • Duplicated block (14 lines × 2) (backend/packages/harness/deerflow/community/browserless/browserless_client.py)
  • …and 170 more

New (607)

  • AioSandbox._exec_owned_shell (cognitive 26) (backend/packages/harness/deerflow/community/aio_sandbox/aio_sandbox.py)
  • AioSandbox._exec_owned_shell (cyclomatic 17) (backend/packages/harness/deerflow/community/aio_sandbox/aio_sandbox.py)
  • AioSandbox._render_bash_output (cognitive 19) (backend/packages/harness/deerflow/community/aio_sandbox/aio_sandbox.py)
  • AioSandbox._run_owned_bash (cognitive 26) (backend/packages/harness/deerflow/community/aio_sandbox/aio_sandbox.py)
  • AioSandbox._run_owned_bash (cyclomatic 18) (backend/packages/harness/deerflow/community/aio_sandbox/aio_sandbox.py)
  • AioSandbox.close (cyclomatic 16) (backend/packages/harness/deerflow/community/aio_sandbox/aio_sandbox.py)
  • BatchContinuations.dispatch (cognitive 32) (backend/app/subagent_batches/continuation.py)
  • BatchContinuations.dispatch (cyclomatic 26) (backend/app/subagent_batches/continuation.py)
  • Boundary-crossing change coupling: page.tsx ↔ chat-page.tsx (frontend/src/app/workspace/agents/[agent_name]/chats/[thread_id]/page.tsx)
  • BrowserSession._ensure_page (cognitive 23) (backend/packages/harness/deerflow/community/browser_automation/session.py)
  • BrowserSession._ensure_page (cyclomatic 18) (backend/packages/harness/deerflow/community/browser_automation/session.py)
  • Change coupling: agent.py ↔ summarization_config.py (backend/packages/harness/deerflow/agents/lead_agent/agent.py)
  • Change coupling: auth.py ↔ page.tsx (backend/app/gateway/routers/auth.py)
  • Change-coupling hub: en-US.ts → page.tsx, memory-settings-page.tsx, settings-dialog.tsx, api.ts (frontend/src/core/i18n/locales/en-US.ts)
  • Change-coupling hub: types.ts → page.tsx, memory-settings-page.tsx, settings-dialog.tsx, api.ts (frontend/src/core/i18n/locales/types.ts)
  • Change-coupling hub: zh-CN.ts → page.tsx, memory-settings-page.tsx, settings-dialog.tsx, welcome.tsx, api.ts (frontend/src/core/i18n/locales/zh-CN.ts)
  • ChannelManager._handle_goal_from_chat (cognitive 22) (backend/app/channels/manager.py)
  • ChannelManager._handle_goal_from_chat (cyclomatic 20) (backend/app/channels/manager.py)
  • DbRunEventStore._admit_events (cognitive 24) (backend/packages/harness/deerflow/runtime/events/store/db.py)
  • DbRunEventStore._admit_events (cyclomatic 20) (backend/packages/harness/deerflow/runtime/events/store/db.py)
  • …and 587 more

Changes since last survey

  • 300 commits — 68 feature/other, 232 fixes

By area

  • backend/packages — 111 commits
  • (root) — 51 commits
  • backend/tests — 42 commits
  • backend/app — 34 commits
  • frontend/src — 22 commits
  • backend/uv.lock — 9 commits
  • backend/AGENTS.md — 4 commits
  • frontend/tests — 4 commits
  • skills/public — 4 commits
  • .github/skill-review-waivers.v1.json — 3 commits
  • backend/docs — 2 commits
  • examples/deerflow-extension-weknora — 2 commits
  • tests/skills — 2 commits
  • .github/workflows — 1 commit
  • backend/scripts — 1 commit
  • deploy/helm — 1 commit
  • docker/lark-cli-broker — 1 commit
  • examples/deerflow-extension-agent-teams — 1 commit
  • examples/deerflow-extension-bookmarks — 1 commit
  • examples/deerflow-extension-example — 1 commit

Notable commits

  • fix: IssueHunter candidate 771965045901: fix for issue #7995 (#7996)
  • fix: chore(checkpoint): require fixed DeltaChannel replay backends (#8139)
  • fix: chore(example): fix the deprecated contextmanager issue (#7974)
  • fix: fix(agent): prevent todo reminders from resuming runs after hard stops (#7955)
  • fix: fix(agents): count model calls independently of reused message IDs (#8050)
  • fix: fix(agents): drop empty typed text blocks from user content (#8066)
  • fix: fix(agents): fence late progress assessments across graph entries (#8083)
  • fix: fix(agents): ignore malformed entries in a serialized MCP routing index (#7751)
  • fix: fix(agents): keep HarnessGuard from rewriting the result that ends a loop (#8001)
  • fix: fix(agents): keep the delegation ledger exact across HITL approval and reused call ids (#8128)
  • fix: fix(agents): keep todo reminders in Goal turns after an earlier provider stop (#8004)
  • fix: fix(agents): pair null call IDs with empty result IDs (#7837)
  • fix: fix(agents): preserve verbatim XML through input sanitization (#7556)
  • fix: fix(agents): remove empty strings from user content (#8038)
  • fix: fix(agents): store an explicit null description as empty (#7638)
  • fix: fix(agents): tolerate deeply nested JSON in tool-call normalization (#7742)
  • fix: fix(agents): tolerate deeply nested JSON tool results (#7679)
  • fix: fix(api): survive a malformed CSRF cookie (#7589)
  • fix: fix(artifacts): authorize shared image reads and offload MIME lookup (#7604)
  • fix: fix(artifacts): bind ranged reads to validated generation (#7978)
  • …and 280 more

Architecture

  • Unchanged — 0 containers · 4 contexts · 0 edges

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

Survey your own repository

bytedance/deer-flow 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 14 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 cee54cdd496f3870f3e7154ba0393f595ad774a9 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-36d4cd83012f.