{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-bytedance--deer-flow","slug":"bytedance--deer-flow","name":"deer-flow","type":"agent","url":"https://deerflow.tech","page_url":"https://unfragile.ai/bytedance--deer-flow","categories":["ai-agents"],"tags":["agent","agentic","agentic-framework","agentic-workflow","ai","ai-agents","deep-research","harness","langchain","langgraph","langmanus","llm","multi-agent","nodejs","podcast","python","superagent","typescript"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-bytedance--deer-flow__cap_0","uri":"capability://planning.reasoning.langgraph.based.agentic.orchestration.with.lead.agent.coordination","name":"langgraph-based agentic orchestration with lead agent coordination","description":"Implements a lead agent pattern using LangGraph's state machine architecture to coordinate multi-step task execution across a distributed agent network. The lead agent maintains a shared state graph that tracks task decomposition, subtask delegation, and result aggregation, with middleware pipeline hooks for pre/post-processing at each graph node. This enables long-horizon task planning where agents can reason about dependencies and execute tasks in parallel or sequential order based on dynamic conditions.","intents":["I need to break down a complex research task into parallel subtasks and have agents work on them simultaneously","I want agents to make decisions about task ordering and dependencies dynamically during execution","I need to track the full execution trace of a multi-agent workflow for debugging and auditing"],"best_for":["teams building autonomous research agents that need to handle tasks spanning minutes to hours","developers implementing multi-agent systems with complex task dependencies","organizations requiring full execution traceability and state management across agent boundaries"],"limitations":["LangGraph state graph adds ~50-100ms latency per node transition due to serialization/deserialization","Middleware pipeline execution is sequential, not parallel — bottleneck for high-frequency state updates","No built-in distributed state consensus — requires external coordination for multi-process deployments"],"requires":["Python 3.9+","LangGraph library (included in LangChain ecosystem)","API key for at least one LLM provider (OpenAI, Anthropic, etc.)"],"input_types":["natural language task descriptions","structured task definitions with dependencies","agent capability manifests"],"output_types":["execution trace with state transitions","task completion status and results","structured subtask decomposition tree"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-bytedance--deer-flow__cap_1","uri":"capability://planning.reasoning.recursive.subagent.delegation.with.task.parallelization","name":"recursive subagent delegation with task parallelization","description":"Implements a hierarchical agent system where the lead agent can spawn child subagents to handle specific task domains, with each subagent capable of spawning further subagents recursively. The subagent executor manages a task queue with configurable parallelism limits, tracks parent-child relationships in thread state, and aggregates results back to the parent context. Each subagent inherits a scoped view of memory, tools, and skills from its parent, enabling domain-specific specialization while maintaining context continuity.","intents":["I want to parallelize independent research tasks across multiple specialized agents","I need agents to delegate work to domain-specific subagents (e.g., code review agent, data analysis agent)","I want to limit concurrent subagent spawning to prevent resource exhaustion"],"best_for":["complex research workflows requiring multiple specialized agents working in parallel","teams building hierarchical agent systems with domain-specific expertise","applications where task parallelism is critical for latency reduction"],"limitations":["Recursive depth is limited by Python stack and memory — typically safe to 5-10 levels deep","Context inheritance creates memory overhead — each subagent copies parent memory state","No automatic load balancing — subagent spawning is greedy without queue awareness"],"requires":["Python 3.9+","Subagent configuration in config.yaml with capability definitions","Memory system initialized (for context inheritance)"],"input_types":["task descriptions with domain hints","parent agent context (memory, tools, skills)","parallelism configuration (max concurrent subagents)"],"output_types":["aggregated results from all subagents","execution timeline showing parallelization","subagent relationship tree"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-bytedance--deer-flow__cap_10","uri":"capability://automation.workflow.configuration.system.with.yaml.based.declarative.setup.and.environment.variable.overrides","name":"configuration system with yaml-based declarative setup and environment variable overrides","description":"Provides a declarative configuration system using YAML files for model selection, tool definitions, skill loading, memory settings, sandbox backends, and channel configurations. The configuration loader supports environment variable overrides, hierarchical config merging (base config + environment-specific overrides), and validation against a schema. Enables deployment flexibility without code changes — same codebase can run with different models, tools, and backends by changing configuration.","intents":["I want to configure the agent (models, tools, skills) without modifying code","I need different configurations for dev, staging, and production environments","I want to enable non-technical users to customize agent behavior via configuration"],"best_for":["teams requiring flexible deployment configurations","platforms supporting user-customizable agent configurations","DevOps workflows where infrastructure is defined as code"],"limitations":["YAML parsing adds ~50-100ms startup time","Configuration validation is static — can't catch runtime incompatibilities","No hot-reloading — configuration changes require agent restart","Complex nested configurations can become hard to maintain"],"requires":["Python 3.9+","config.yaml file in project root or specified path","Environment variables for sensitive values (API keys, etc.)"],"input_types":["YAML configuration files","environment variables","schema definitions"],"output_types":["parsed configuration objects","validation errors","merged config (base + overrides)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-bytedance--deer-flow__cap_11","uri":"capability://tool.use.integration.api.gateway.with.request.routing.and.response.streaming","name":"api gateway with request routing and response streaming","description":"Implements an HTTP API gateway that routes requests to the LangGraph agent server, manages request/response serialization, and supports streaming responses via Server-Sent Events (SSE) or chunked transfer encoding. The gateway handles authentication (API keys, JWT), rate limiting, request validation, and error responses with appropriate HTTP status codes. Provides REST endpoints for chat, thread management, artifact retrieval, and configuration queries.","intents":["I want a REST API for integrating agents into external applications","I need streaming responses so clients can process agent outputs incrementally","I want to enforce rate limiting and authentication on agent access"],"best_for":["teams integrating agents into larger applications via API","multi-tenant deployments requiring per-user rate limiting","systems needing programmatic access to agent capabilities"],"limitations":["SSE streaming has browser compatibility issues (no IE support)","Request routing adds ~10-20ms latency per request","Rate limiting is per-endpoint, not global — can't prevent coordinated attacks","No built-in request queuing — high concurrency can cause timeouts"],"requires":["Python 3.9+","HTTP server framework (FastAPI, Flask, etc.)","Authentication mechanism (API keys, JWT, etc.)"],"input_types":["HTTP requests (JSON body)","authentication headers","query parameters"],"output_types":["JSON responses","streaming event streams (SSE)","HTTP status codes"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-bytedance--deer-flow__cap_12","uri":"capability://automation.workflow.middleware.pipeline.with.pre.post.processing.hooks.for.agent.execution","name":"middleware pipeline with pre/post-processing hooks for agent execution","description":"Implements a composable middleware system that intercepts agent execution at key points (before LLM call, after tool execution, before response to user) and applies transformations or validations. Middleware can be chained in sequence, with each middleware receiving the execution context and able to modify state, inject additional context, or short-circuit execution. Enables cross-cutting concerns like logging, monitoring, content filtering, and context enrichment without modifying agent code.","intents":["I want to add logging and monitoring without modifying agent code","I need to apply content filtering at multiple execution stages","I want to enrich agent context with additional data (user profile, system state) dynamically"],"best_for":["teams requiring observability and monitoring across agent execution","systems with complex cross-cutting concerns (logging, filtering, enrichment)","platforms supporting extensible agent behavior via middleware"],"limitations":["Middleware execution is sequential — each middleware adds latency","Middleware ordering matters but is not automatically validated","No built-in middleware composition patterns — requires manual chaining","Middleware errors can break the entire execution pipeline"],"requires":["Python 3.9+","Middleware implementations (custom or built-in)","Middleware configuration in config.yaml"],"input_types":["execution context (messages, state, tools)","middleware definitions","transformation logic"],"output_types":["modified execution context","side effects (logs, metrics, etc.)","execution decisions (continue, short-circuit, etc.)"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-bytedance--deer-flow__cap_13","uri":"capability://search.retrieval.web.search.and.information.retrieval.integration.via.tools","name":"web search and information retrieval integration via tools","description":"Integrates web search capabilities (via search APIs or MCP servers) as agent tools, enabling agents to query the internet for current information, research topics, and fact-checking. The search integration supports multiple search backends (Google, Bing, DuckDuckGo), result filtering and ranking, and caching of search results to reduce API calls. Agents can use search results to augment their knowledge and provide up-to-date information in responses.","intents":["I want agents to search the web for current information and recent events","I need agents to fact-check claims against web sources","I want to reduce hallucinations by grounding agent responses in web search results"],"best_for":["research agents requiring access to current information","fact-checking systems needing web verification","applications where up-to-date information is critical"],"limitations":["Web search adds 1-3 seconds latency per search query","Search result quality varies by query — requires result ranking/filtering","Search APIs have rate limits and costs","Search results can be stale or contain misinformation"],"requires":["Python 3.9+","Search API key (Google, Bing, etc.) OR MCP search server","Search tool configured in config.yaml"],"input_types":["search queries (natural language or structured)","search parameters (number of results, language, etc.)"],"output_types":["search results (title, URL, snippet)","result ranking/relevance scores","cached results"],"categories":["search-retrieval","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-bytedance--deer-flow__cap_2","uri":"capability://code.generation.editing.sandboxed.code.and.bash.execution.with.multiple.backend.providers","name":"sandboxed code and bash execution with multiple backend providers","description":"Provides isolated execution environments for arbitrary code (Python, bash, etc.) using pluggable sandbox backends (Docker, Kubernetes, local process isolation). The sandbox system implements path virtualization to prevent directory traversal attacks, manages resource limits (CPU, memory, timeout), and provides a tool interface for agents to execute code without direct system access. Supports multiple concurrent sandbox instances with automatic cleanup and configurable backend selection per deployment environment.","intents":["I need agents to execute code safely without compromising the host system","I want to run code in isolated environments with resource limits and timeout protection","I need to support multiple sandbox backends (Docker for dev, Kubernetes for production)"],"best_for":["teams deploying agents that need to execute untrusted code","research platforms requiring reproducible code execution","production systems needing multi-tenant isolation"],"limitations":["Docker backend adds 2-5 second startup latency per sandbox instance","Path virtualization overhead is ~10-20ms per file operation","No inter-sandbox communication — each sandbox is completely isolated","Resource limits are enforced at container level, not granular per-process"],"requires":["Python 3.9+","Docker daemon running (for Docker backend) OR Kubernetes cluster (for K8s backend)","Sandbox configuration in config.yaml with backend selection","Appropriate system permissions for container/process management"],"input_types":["Python code strings","bash command strings","file paths for code execution","environment variables"],"output_types":["stdout/stderr from execution","exit code","execution duration","generated files (if any)"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-bytedance--deer-flow__cap_3","uri":"capability://memory.knowledge.persistent.memory.system.with.confidence.scored.facts.and.summarization","name":"persistent memory system with confidence-scored facts and summarization","description":"Maintains a long-term memory store that persists facts extracted from conversations with confidence scores indicating reliability. The memory system uses an LLM-based extraction pipeline to identify and store facts from agent outputs, implements a summarization mechanism to compress old memories when reaching capacity limits, and provides a retrieval interface for agents to query relevant facts during task execution. Memory is scoped per conversation thread and can be selectively cleared or updated based on confidence thresholds.","intents":["I want agents to remember facts across multiple conversations and use them in future tasks","I need to track information reliability — distinguish high-confidence facts from speculative ones","I want automatic memory compression so the system doesn't grow unbounded"],"best_for":["long-running research agents that need to accumulate knowledge over time","multi-turn conversational agents where context persistence is critical","systems requiring audit trails of what the agent learned and when"],"limitations":["Memory extraction adds ~500ms-1s per agent response due to LLM inference","Summarization is lossy — compressed memories may lose nuance","No semantic deduplication — similar facts can be stored multiple times","Confidence scoring is heuristic-based, not ground-truth validated"],"requires":["Python 3.9+","LLM API key for memory extraction and summarization","Persistent storage backend (SQLite, PostgreSQL, etc.)","Memory configuration in config.yaml with extraction prompts"],"input_types":["agent response text","conversation history","manual memory updates"],"output_types":["structured facts with confidence scores","memory summaries","retrieved relevant facts for context"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-bytedance--deer-flow__cap_4","uri":"capability://tool.use.integration.extensible.skills.system.with.skill.archive.loading.and.composition","name":"extensible skills system with .skill archive loading and composition","description":"Provides a plugin architecture for loading specialized workflows as .skill archives (compressed bundles containing prompts, tools, and configuration). Skills are loaded dynamically at runtime and composed into the agent's capability set, with each skill defining its own system prompts, tool bindings, and execution hooks. The skills system enables domain-specific agent specialization without modifying core agent code, supporting skill versioning and conditional loading based on task requirements.","intents":["I want to add specialized capabilities to agents without forking the codebase","I need to package domain-specific workflows (e.g., 'research skill', 'coding skill') as reusable components","I want to enable users to create and share custom skills"],"best_for":["platforms building extensible agent systems","teams with multiple specialized domains requiring different agent behaviors","open-source communities wanting to contribute domain-specific skills"],"limitations":["Skill loading adds ~100-200ms per skill due to archive extraction and parsing","No automatic conflict resolution — overlapping tool names between skills can cause collisions","Skills are loaded at startup — no hot-reloading during agent execution","Skill versioning is manual — no dependency resolution between skills"],"requires":["Python 3.9+","Skills directory configured in config.yaml",".skill archive files with proper structure (prompts/, tools/, config.yaml)"],"input_types":[".skill archive files","skill configuration YAML","skill prompts and tool definitions"],"output_types":["loaded skill capabilities","composed system prompts","merged tool registry"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-bytedance--deer-flow__cap_5","uri":"capability://tool.use.integration.tool.system.with.mcp.server.integration.and.dynamic.function.calling","name":"tool system with mcp server integration and dynamic function calling","description":"Implements a unified tool registry that supports both native Python tools and Model Context Protocol (MCP) servers, enabling agents to call functions with schema-based validation. The tool system generates OpenAI/Anthropic-compatible function calling schemas from tool definitions, manages tool execution with error handling and retry logic, and supports streaming responses for long-running tools. Tools can be conditionally loaded based on agent capabilities and task context.","intents":["I want agents to call external APIs and functions with type-safe schemas","I need to integrate MCP servers (like web search, file operations) into agent workflows","I want to support multiple LLM providers' function calling APIs with a single tool definition"],"best_for":["agents requiring integration with external APIs and services","teams standardizing on MCP for tool interoperability","multi-provider LLM deployments needing provider-agnostic tool definitions"],"limitations":["MCP server startup adds 1-2 seconds per server initialization","Schema generation from Python functions is best-effort — complex types may not translate perfectly","Tool execution errors are caught but not automatically recovered — requires agent-level retry logic","No built-in rate limiting — agents can overwhelm external APIs without throttling"],"requires":["Python 3.9+","Tool definitions in config.yaml or as Python functions","MCP server binaries (if using MCP tools)","API keys for external services (if applicable)"],"input_types":["tool definitions (Python functions or YAML specs)","MCP server configurations","function call requests from LLM"],"output_types":["function call results","error messages with context","streaming responses (for long-running tools)"],"categories":["tool-use-integration","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-bytedance--deer-flow__cap_6","uri":"capability://tool.use.integration.multi.channel.deployment.with.im.gateway.abstraction","name":"multi-channel deployment with im gateway abstraction","description":"Provides a message gateway abstraction that enables deployment across multiple communication channels (Slack, Discord, Telegram, etc.) without modifying agent code. The IM channels architecture translates between channel-specific message formats and a unified internal message protocol, manages channel-specific state (user sessions, thread contexts), and handles authentication/authorization per channel. Supports streaming responses and rich message formatting (buttons, embeds) with graceful degradation for channels with limited capabilities.","intents":["I want to deploy the same agent across Slack, Discord, and other chat platforms","I need to maintain separate user sessions and conversation contexts per channel","I want to support rich message formatting (buttons, embeds) where available"],"best_for":["teams deploying agents across multiple communication platforms","organizations with existing Slack/Discord/Telegram infrastructure","products requiring omnichannel agent availability"],"limitations":["Channel-specific features (buttons, embeds) require custom handling per channel","Message rate limits vary by channel — no unified rate limiting strategy","State synchronization across channels is eventual, not immediate","Rich formatting degrades to plain text on channels without support"],"requires":["Python 3.9+","Channel configuration in config.yaml with API credentials","API tokens/webhooks for each channel (Slack bot token, Discord webhook, etc.)","Message gateway implementation for each channel type"],"input_types":["channel-specific message formats","user authentication tokens","channel configuration"],"output_types":["unified internal message protocol","channel-specific formatted responses","streaming message updates"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-bytedance--deer-flow__cap_7","uri":"capability://safety.moderation.guardrails.system.with.content.filtering.and.alignment.enforcement","name":"guardrails system with content filtering and alignment enforcement","description":"Implements a safety layer that validates agent outputs against configurable guardrails before sending to users, including content filtering (blocking harmful content), alignment checks (ensuring outputs match system values), and rate limiting. The guardrails system uses both rule-based filters and LLM-based semantic validation, supports custom guardrail definitions, and logs all filtered content for audit purposes. Guardrails can be applied at multiple stages (tool execution, agent output, user response).","intents":["I want to prevent agents from generating harmful, illegal, or inappropriate content","I need to enforce brand values and alignment in agent outputs","I want to audit what content was filtered and why"],"best_for":["production deployments requiring content safety","regulated industries (healthcare, finance) with compliance requirements","public-facing agents where brand reputation is critical"],"limitations":["LLM-based guardrails add 200-500ms latency per validation","Rule-based filters can have false positives/negatives — require tuning","Guardrails are applied post-generation, not during — can't prevent harmful reasoning","Custom guardrail definitions require domain expertise to write effectively"],"requires":["Python 3.9+","Guardrails configuration in config.yaml","LLM API key (for semantic validation guardrails)","Audit logging infrastructure"],"input_types":["agent outputs (text, code, etc.)","guardrail rule definitions","custom validation logic"],"output_types":["filtered/approved outputs","filtering decisions with reasons","audit logs"],"categories":["safety-moderation","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-bytedance--deer-flow__cap_8","uri":"capability://memory.knowledge.thread.based.conversation.state.management.with.artifact.tracking","name":"thread-based conversation state management with artifact tracking","description":"Manages conversation state per thread (conversation ID), tracking message history, subtask execution, generated artifacts (code, documents, etc.), and intermediate results. The state management system persists thread state to a backend store, enables resuming interrupted conversations, and provides a unified view of all artifacts generated during a conversation. Supports thread forking (creating branches from a conversation point) and merging results from parallel subtasks back into the main thread state.","intents":["I want conversations to persist across sessions so users can resume where they left off","I need to track all artifacts (code, documents, files) generated during a conversation","I want to support branching conversations where users explore alternative paths"],"best_for":["long-running research workflows requiring conversation persistence","applications where users need to review and download generated artifacts","systems supporting collaborative workflows with conversation branching"],"limitations":["Thread state serialization adds ~50-100ms per state update","Artifact storage requires external file system or object storage","No automatic garbage collection — old threads accumulate indefinitely","Merging parallel subtask results can create state conflicts without explicit resolution"],"requires":["Python 3.9+","Persistent storage backend (SQLite, PostgreSQL, etc.)","File storage backend (local filesystem, S3, etc.) for artifacts","Thread state schema defined in backend"],"input_types":["conversation messages","subtask results","generated artifacts","thread fork/merge operations"],"output_types":["thread state snapshots","artifact manifests","conversation history","thread relationship graphs"],"categories":["memory-knowledge","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-bytedance--deer-flow__cap_9","uri":"capability://text.generation.language.frontend.chat.interface.with.real.time.streaming.and.message.rendering","name":"frontend chat interface with real-time streaming and message rendering","description":"Provides a React-based web UI with real-time message streaming, progressive rendering of agent outputs, and rich message formatting (code blocks, tables, markdown). The frontend implements a message rendering system that handles different message types (text, code, artifacts, suggestions), displays subtask execution progress, and provides controls for thread management (fork, branch, resume). Uses WebSocket connections for streaming responses and maintains local state for optimistic UI updates.","intents":["I want users to see agent responses stream in real-time rather than waiting for completion","I need to display code, artifacts, and other rich content in a readable format","I want to show subtask progress and execution trees to users"],"best_for":["web-based agent deployments requiring responsive UX","research platforms where users need to monitor long-running tasks","applications requiring rich content rendering (code, documents, visualizations)"],"limitations":["WebSocket connections add complexity for deployment (requires reverse proxy support)","Large message histories can cause frontend performance degradation (100+ messages)","Rich formatting requires custom renderers for each content type","Real-time streaming requires careful error handling for network interruptions"],"requires":["Node.js 18+","React 18+","WebSocket support in deployment infrastructure","TypeScript (frontend is written in TypeScript)"],"input_types":["streaming message chunks","artifact metadata","execution progress updates"],"output_types":["rendered HTML/React components","user interactions (message submission, thread controls)","artifact downloads"],"categories":["text-generation-language","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":56,"verified":false,"data_access_risk":"high","permissions":["Python 3.9+","LangGraph library (included in LangChain ecosystem)","API key for at least one LLM provider (OpenAI, Anthropic, etc.)","Subagent configuration in config.yaml with capability definitions","Memory system initialized (for context inheritance)","config.yaml file in project root or specified path","Environment variables for sensitive values (API keys, etc.)","HTTP server framework (FastAPI, Flask, etc.)","Authentication mechanism (API keys, JWT, etc.)","Middleware implementations (custom or built-in)"],"failure_modes":["LangGraph state graph adds ~50-100ms latency per node transition due to serialization/deserialization","Middleware pipeline execution is sequential, not parallel — bottleneck for high-frequency state updates","No built-in distributed state consensus — requires external coordination for multi-process deployments","Recursive depth is limited by Python stack and memory — typically safe to 5-10 levels deep","Context inheritance creates memory overhead — each subagent copies parent memory state","No automatic load balancing — subagent spawning is greedy without queue awareness","YAML parsing adds ~50-100ms startup time","Configuration validation is static — can't catch runtime incompatibilities","No hot-reloading — configuration changes require agent restart","Complex nested configurations can become hard to maintain","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.8623371137115412,"quality":0.5,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.1,"match_graph":0.28,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:21.549Z","last_scraped_at":"2026-05-03T13:57:06.483Z","last_commit":"2026-05-02T14:08:11Z"},"community":{"stars":64562,"forks":8493,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=bytedance--deer-flow","compare_url":"https://unfragile.ai/compare?artifact=bytedance--deer-flow"}},"signature":"SzVf+JmqhniuixCszizigBDUXIdZcffXn5W+E6m0vDBSsMieETzwqFnueTRNOJaqmEukNszhw1cUIkdeLycOAA==","signedAt":"2026-06-22T02:56:34.342Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/bytedance--deer-flow","artifact":"https://unfragile.ai/bytedance--deer-flow","verify":"https://unfragile.ai/api/v1/verify?slug=bytedance--deer-flow","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}