{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-hkuds--deepcode","slug":"hkuds--deepcode","name":"DeepCode","type":"agent","url":"http://arxiv.org/abs/2512.07921","page_url":"https://unfragile.ai/hkuds--deepcode","categories":["productivity"],"tags":["agentic-coding","llm-agent"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"inactive","verified":false},"capabilities":[{"id":"github-hkuds--deepcode__cap_0","uri":"capability://tool.use.integration.multi.agent.orchestration.via.model.context.protocol.mcp","name":"multi-agent orchestration via model context protocol (mcp)","description":"Coordinates specialized AI agents through MCP tool servers, enabling distributed task execution where each agent handles specific responsibilities (requirement analysis, code generation, testing) and communicates through standardized MCP interfaces. The orchestration layer routes tasks to appropriate agents based on pipeline stage and maintains state across multi-step workflows without direct agent-to-agent coupling.","intents":["I need multiple AI agents to collaborate on code generation without building custom IPC","I want to scale code generation by distributing work across specialized agents","I need to swap out LLM providers or agents without rewriting orchestration logic"],"best_for":["teams building complex agentic systems requiring agent specialization","developers wanting MCP-native multi-agent frameworks without custom orchestration","organizations needing pluggable agent architectures for different code generation tasks"],"limitations":["MCP overhead adds latency per agent handoff (~100-300ms depending on tool complexity)","No built-in agent failure recovery — requires external orchestration layer for resilience","Agent state synchronization relies on explicit context passing; no implicit shared memory between agents"],"requires":["Python 3.9+","MCP server implementation (provided in mcp_agent.config.yaml)","LLM provider API keys (OpenAI, Anthropic, or compatible)","Model Context Protocol client library"],"input_types":["task specifications (JSON)","agent configuration (YAML)","context objects (structured data)"],"output_types":["generated code (Python, JavaScript, etc.)","execution logs (JSON)","agent state snapshots (structured data)"],"categories":["tool-use-integration","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--deepcode__cap_1","uri":"capability://code.generation.editing.research.to.code.pipeline.with.document.segmentation","name":"research-to-code pipeline with document segmentation","description":"Transforms academic papers and technical specifications into production code through a structured pipeline that extracts research content, segments documents into logical chunks, analyzes requirements, and generates implementation code with tests and documentation. The pipeline uses document processing tools to parse PDFs/arXiv URLs, segments content by semantic boundaries, and feeds segmented context to code generation agents to maintain coherence across multi-file implementations.","intents":["I want to implement an algorithm from a research paper without manually translating it","I need to generate code from technical specifications with automatic requirement extraction","I want to create reproducible implementations of academic work with tests and docs"],"best_for":["researchers implementing their own papers","ML engineers translating academic work to production code","teams building algorithm libraries from published research"],"limitations":["Accuracy depends on paper clarity — dense mathematical notation may require manual clarification","Document segmentation uses heuristic boundaries; complex multi-section papers may need custom chunking strategies","Generated code requires human review for production use; no formal verification of algorithmic correctness"],"requires":["Python 3.9+","PDF parsing library (PyPDF2 or similar)","arXiv API access for paper fetching","LLM with 8k+ token context window"],"input_types":["PDF files","arXiv URLs","DOCX documents","plain text specifications"],"output_types":["Python/JavaScript implementation code","unit tests","API documentation","implementation notes"],"categories":["code-generation-editing","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--deepcode__cap_10","uri":"capability://tool.use.integration.llm.communication.with.error.handling.and.retry.logic","name":"llm communication with error handling and retry logic","description":"Implements robust LLM communication through a wrapper layer that handles provider-specific errors, implements exponential backoff retry logic, manages token limits, and provides detailed error reporting. The system catches rate limit errors, API timeouts, and context window overflows, retries with backoff, and falls back to alternative providers or degraded modes when primary providers fail, ensuring resilience in production code generation pipelines.","intents":["I want reliable LLM communication with automatic retry on transient failures","I need to handle rate limits and context window overflows gracefully","I want detailed error reporting for debugging LLM failures"],"best_for":["production code generation pipelines requiring high availability","teams using rate-limited LLM APIs","developers building resilient agentic systems"],"limitations":["Retry logic adds latency (exponential backoff can exceed 1 minute for persistent failures)","Context window overflow handling requires fallback strategies (chunking, summarization) that may degrade output quality","Provider-specific error codes are not fully standardized; some errors may not be retried correctly","No built-in circuit breaker; repeated failures will continue retrying until timeout"],"requires":["Python 3.9+","LLM provider API keys","Logging infrastructure for error reporting","Timeout configuration (default: 60 seconds)"],"input_types":["LLM requests (prompts, function calls)","retry configuration (max attempts, backoff strategy)"],"output_types":["LLM responses (on success)","error reports (structured data)","retry metrics (attempt count, backoff duration)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--deepcode__cap_11","uri":"capability://text.generation.language.prompt.templates.and.agent.instruction.management","name":"prompt templates and agent instruction management","description":"Manages a library of prompt templates and agent-specific instructions that guide LLM behavior for different code generation tasks (Paper2Code, Text2Web, Text2Backend, requirement analysis). The system uses template variables for dynamic prompt construction, maintains version-controlled instruction sets, and allows customization of prompts for domain-specific code generation without modifying core agent logic.","intents":["I want to customize LLM behavior for specific code generation tasks","I need to version-control and test different prompt strategies","I want to reuse prompt templates across multiple agents"],"best_for":["teams optimizing code generation quality through prompt engineering","organizations with domain-specific code generation requirements","developers experimenting with different LLM instruction strategies"],"limitations":["Prompt quality is highly dependent on LLM capability; no guarantee of consistent output across LLM versions","Template variables require careful escaping; complex variable substitution may introduce errors","No built-in A/B testing framework; comparing prompt strategies requires manual experimentation","Prompt changes require redeployment; no hot-reload for prompt updates"],"requires":["Python 3.9+","Template engine (Jinja2 or similar)","Version control system for prompt tracking","LLM with sufficient instruction-following capability"],"input_types":["prompt templates (text with variables)","template variables (key-value pairs)","agent instructions (text)"],"output_types":["rendered prompts (text)","agent instructions (text)"],"categories":["text-generation-language","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--deepcode__cap_12","uri":"capability://automation.workflow.docker.deployment.with.containerized.execution","name":"docker deployment with containerized execution","description":"Provides Docker containerization for DeepCode enabling isolated, reproducible execution environments with all dependencies pre-installed. The system includes a Dockerfile that packages Python runtime, dependencies, and DeepCode code, with entrypoint scripts that support both CLI and web UI modes, allowing deployment to Kubernetes, cloud platforms, or local Docker environments without manual dependency management.","intents":["I want to deploy DeepCode in a containerized environment (Docker/Kubernetes)","I need reproducible execution environments across development and production","I want to isolate DeepCode from system dependencies"],"best_for":["DevOps teams deploying DeepCode to cloud platforms","organizations using Kubernetes for orchestration","developers wanting reproducible local development environments"],"limitations":["Docker image size is large (>1GB) due to Python dependencies; slow to pull in bandwidth-constrained environments","LLM API keys must be injected at runtime; no built-in secret management","GPU support requires additional Docker configuration (nvidia-docker); not included by default","Volume mounting for code input/output requires explicit configuration"],"requires":["Docker 20.10+","Docker Compose (optional, for multi-container setups)","LLM API keys (passed as environment variables)","Sufficient disk space for image (~1GB)"],"input_types":["Docker build arguments","environment variables (API keys, config)","mounted volumes (code input/output)"],"output_types":["Docker image","running container with accessible API/CLI"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--deepcode__cap_13","uri":"capability://automation.workflow.configuration.management.via.yaml.with.secrets.handling","name":"configuration management via yaml with secrets handling","description":"Manages DeepCode configuration through YAML files (mcp_agent.config.yaml, mcp_agent.secrets.yaml) that define agent settings, LLM provider configuration, tool definitions, and pipeline parameters. The system separates secrets (API keys) from configuration, supports environment variable substitution, and validates configuration at startup, enabling environment-specific deployments without code changes.","intents":["I want to configure DeepCode for different environments (dev, staging, prod) without code changes","I need to manage API keys and secrets securely","I want to customize agent behavior and pipeline parameters via configuration"],"best_for":["DevOps teams managing multiple DeepCode deployments","organizations with strict configuration management policies","developers wanting environment-specific configurations"],"limitations":["YAML validation is basic; complex configuration errors may not be caught until runtime","Secrets file (mcp_agent.secrets.yaml) is not encrypted; requires external secret management (Vault, AWS Secrets Manager)","No built-in configuration versioning; manual tracking required","Environment variable substitution is simple string replacement; no complex templating"],"requires":["Python 3.9+","YAML parser (PyYAML)","Configuration files (mcp_agent.config.yaml, mcp_agent.secrets.yaml)","Environment variables for secrets (optional)"],"input_types":["YAML configuration files","environment variables","command-line arguments (override config)"],"output_types":["parsed configuration (Python dict)","validation errors (if config is invalid)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--deepcode__cap_2","uri":"capability://code.generation.editing.concise.memory.agent.with.single.file.and.batch.modes","name":"concise memory agent with single-file and batch modes","description":"Implements a memory-efficient code generation agent that operates in two modes: single-file mode for focused implementations and multi-file batch mode for coordinated generation across multiple files. The agent uses a concise memory representation that tracks only essential context (function signatures, dependencies, type hints) rather than full file contents, enabling processing of large codebases within token budgets while maintaining cross-file consistency through reference indexing.","intents":["I need to generate code for large projects without exceeding LLM context limits","I want to maintain consistency across multiple generated files without reprocessing entire codebase","I need to batch-generate multiple files efficiently with shared context"],"best_for":["developers working with large codebases (10k+ LOC)","teams generating multiple interdependent files in parallel","cost-conscious builders minimizing token usage per generation task"],"limitations":["Concise memory representation may lose implementation details needed for complex refactoring","Batch mode requires pre-computed dependency graph; circular dependencies need manual resolution","Single-file mode cannot reference implementations from other files; requires explicit context injection"],"requires":["Python 3.9+","Reference indexing system (built-in)","LLM with at least 4k token context","File system access for reading/writing code"],"input_types":["code files (Python, JavaScript, etc.)","dependency specifications (JSON/YAML)","generation prompts (text)"],"output_types":["generated code files","memory snapshots (JSON)","dependency graphs (structured data)"],"categories":["code-generation-editing","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--deepcode__cap_3","uri":"capability://code.generation.editing.text.to.web.frontend.generation.with.html.css.javascript.output","name":"text-to-web frontend generation with html/css/javascript output","description":"Generates complete frontend web applications from natural language requirements by decomposing UI specifications into component hierarchies, styling rules, and interactive logic. The system translates requirement text into structured component definitions, applies design patterns (responsive layouts, accessibility standards), and generates production-ready HTML/CSS/JavaScript with integrated state management and event handling.","intents":["I want to generate a web UI from a text description without manual HTML/CSS coding","I need to create responsive web applications with accessibility built-in","I want to prototype web interfaces quickly from requirements"],"best_for":["non-technical founders prototyping web MVPs","full-stack developers accelerating frontend scaffolding","teams generating multiple UI variants from specifications"],"limitations":["Generated UIs may require manual refinement for complex interactions or custom animations","Accessibility compliance depends on LLM understanding of WCAG standards; manual audit recommended","No built-in design system enforcement; generated styles may lack consistency across multiple pages"],"requires":["Python 3.9+","LLM with understanding of HTML/CSS/JavaScript patterns","Node.js 14+ for optional build tooling","Web browser for testing generated output"],"input_types":["natural language requirements (text)","wireframes or design descriptions","component specifications (JSON)"],"output_types":["HTML files","CSS stylesheets","JavaScript files (vanilla or framework-specific)","component documentation"],"categories":["code-generation-editing","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--deepcode__cap_4","uri":"capability://code.generation.editing.text.to.backend.service.implementation.with.api.endpoint.generation","name":"text-to-backend service implementation with api endpoint generation","description":"Generates backend server code and API endpoints from API specifications and text descriptions by analyzing endpoint requirements, inferring data models, generating request/response handlers, and creating database schemas. The system translates specification text into OpenAPI-compatible endpoint definitions, generates handler functions with input validation and error handling, and produces database migration scripts for schema initialization.","intents":["I want to generate a REST API backend from specification without manual endpoint coding","I need to create database schemas and migrations from API requirements","I want to generate server code with built-in validation and error handling"],"best_for":["backend developers accelerating API scaffolding","teams generating microservices from specifications","startups building MVPs with minimal backend engineering"],"limitations":["Generated endpoints may lack complex business logic; requires manual implementation for domain-specific rules","Database schema inference from text is heuristic-based; complex relationships need explicit specification","No built-in authentication/authorization generation; security policies must be added manually"],"requires":["Python 3.9+","LLM with API design and database schema knowledge","Framework support (Flask, FastAPI, Django, or Node.js/Express)","Database system (PostgreSQL, MySQL, or SQLite)"],"input_types":["API specifications (OpenAPI/Swagger YAML)","text descriptions of endpoints","data model specifications (JSON Schema)"],"output_types":["Python/JavaScript server code","database migration scripts","API documentation (OpenAPI spec)","unit tests for endpoints"],"categories":["code-generation-editing","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--deepcode__cap_5","uri":"capability://planning.reasoning.requirement.analysis.workflow.with.user.in.loop.plugin.system","name":"requirement analysis workflow with user-in-loop plugin system","description":"Analyzes high-level requirements through a structured workflow that extracts functional specifications, identifies dependencies, and flags ambiguities, with a plugin system enabling human review and clarification at critical decision points. The workflow uses NLP-based requirement parsing to decompose specifications into user stories, generates clarification questions for ambiguous requirements, and allows users to inject domain knowledge through plugins before code generation proceeds.","intents":["I want to validate requirements before code generation to catch ambiguities early","I need to extract structured specifications from natural language descriptions","I want to involve domain experts in the code generation pipeline without rewriting the system"],"best_for":["teams with domain experts who need to validate requirements","organizations building custom code generation workflows","projects where requirement clarity is critical (regulated industries, complex domains)"],"limitations":["Plugin system requires custom Python code; no visual plugin builder","Requirement parsing accuracy depends on specification clarity; poorly written requirements may generate misleading questions","User-in-loop adds latency; asynchronous plugin execution not fully supported"],"requires":["Python 3.9+","Plugin interface implementation (Python classes)","LLM for requirement parsing and question generation","User interface for plugin interaction (CLI or web UI)"],"input_types":["natural language requirements (text)","structured specifications (JSON/YAML)","domain context (text or documents)"],"output_types":["parsed requirements (JSON)","clarification questions (text)","dependency graphs (structured data)","plugin execution results (custom)"],"categories":["planning-reasoning","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--deepcode__cap_6","uri":"capability://code.generation.editing.code.implementation.with.reference.indexing.and.cross.file.consistency","name":"code implementation with reference indexing and cross-file consistency","description":"Generates code across multiple files while maintaining consistency through a reference indexing system that tracks function signatures, type definitions, and API contracts across the codebase. The system builds an index of existing code elements, resolves cross-file references during generation, and validates generated code against indexed contracts to prevent breaking changes or type mismatches between files.","intents":["I need to generate multiple files that reference each other without manual synchronization","I want to ensure generated code maintains type safety across file boundaries","I need to extend existing codebases without breaking cross-file dependencies"],"best_for":["teams generating code for large multi-file projects","developers extending existing codebases with generated code","organizations requiring type-safe code generation across modules"],"limitations":["Reference indexing requires pre-computed index; large codebases (100k+ LOC) may have slow index generation","Type inference is language-specific; requires language-specific parsers for each supported language","Circular dependencies between files require manual resolution; no automatic cycle detection"],"requires":["Python 3.9+","Language-specific AST parsers (tree-sitter or similar)","Reference index database (in-memory or persistent)","Type inference engine for target language"],"input_types":["existing code files","generation specifications","type definitions (TypeScript, Python type hints, etc.)"],"output_types":["generated code files","reference index (JSON)","validation reports (structured data)"],"categories":["code-generation-editing","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--deepcode__cap_7","uri":"capability://tool.use.integration.multi.interface.access.cli.react.ui.streamlit.feishu.nanobot","name":"multi-interface access (cli, react ui, streamlit, feishu nanobot)","description":"Provides multiple user interfaces for accessing DeepCode functionality: a command-line interface for CI/CD integration and automation, a modern React-based web UI with real-time streaming and task recovery, a legacy Streamlit interface for quick prototyping, and a Feishu (nanobot) chat integration for team collaboration. Each interface connects to a shared backend API (FastAPI) that orchestrates the code generation pipeline, enabling users to choose their preferred interaction model without duplicating core logic.","intents":["I want to integrate code generation into CI/CD pipelines via CLI","I need a visual interface for interactive code generation with real-time feedback","I want to collaborate on code generation through chat (Feishu/Slack-like)","I need to quickly prototype code generation workflows without building custom UI"],"best_for":["DevOps engineers integrating code generation into CI/CD","teams using Feishu for internal collaboration","developers preferring CLI-based workflows","non-technical users needing visual interfaces"],"limitations":["CLI interface lacks real-time streaming; requires polling for task status","React UI requires Node.js 14+ and modern browser; not suitable for headless environments","Feishu integration is China-specific; limited availability in other regions","Streamlit interface has performance limitations for large codebases (>50k LOC)"],"requires":["Python 3.9+ (backend)","Node.js 14+ (React UI)","FastAPI for backend API","Feishu workspace (for nanobot integration)","Modern web browser (for React UI)"],"input_types":["CLI arguments and flags","web form inputs (React UI)","chat messages (Feishu nanobot)","file uploads (all interfaces)"],"output_types":["generated code files","execution logs (CLI)","real-time streaming updates (React UI)","chat responses (Feishu)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--deepcode__cap_8","uri":"capability://tool.use.integration.llm.provider.abstraction.with.multi.provider.support","name":"llm provider abstraction with multi-provider support","description":"Abstracts LLM interactions behind a provider-agnostic interface that supports OpenAI, Anthropic, and compatible providers (including local models via Ollama), enabling users to swap providers without code changes. The abstraction handles provider-specific API differences (function calling schemas, context window limits, token counting), manages API key configuration through environment variables or config files, and implements retry logic and error handling for provider-specific failures.","intents":["I want to switch between OpenAI and Anthropic without rewriting code","I need to use local LLMs (Ollama) for privacy or cost reasons","I want to handle provider-specific errors and rate limits gracefully"],"best_for":["teams evaluating multiple LLM providers","organizations with privacy requirements (on-premise LLMs)","cost-conscious builders wanting to switch providers based on pricing","developers building provider-agnostic LLM applications"],"limitations":["Provider abstraction cannot hide all differences; some advanced features (vision, function calling) are provider-specific","Token counting is approximate; actual token usage may vary by provider","Rate limiting is handled per-provider; no global rate limiting across providers","Context window limits vary significantly; code must handle provider-specific limits"],"requires":["Python 3.9+","API keys for at least one provider (OpenAI, Anthropic, or Ollama)","Configuration file (mcp_agent.config.yaml) or environment variables","Network access to provider APIs (or local Ollama instance)"],"input_types":["prompts (text)","function schemas (JSON)","context objects (structured data)"],"output_types":["LLM responses (text)","function calls (JSON)","token usage metrics (structured data)"],"categories":["tool-use-integration","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--deepcode__cap_9","uri":"capability://data.processing.analysis.file.and.document.processing.with.multi.format.support","name":"file and document processing with multi-format support","description":"Processes multiple document formats (PDF, DOCX, plain text, arXiv URLs) through a unified pipeline that extracts text, preserves structure (sections, headings, tables), and segments content for downstream processing. The system uses format-specific parsers (PyPDF2 for PDFs, python-docx for DOCX), fetches papers from arXiv API, and applies heuristic-based segmentation to split documents into logical chunks while preserving semantic boundaries.","intents":["I want to extract text and structure from PDFs and DOCX files","I need to fetch and process papers directly from arXiv","I want to segment documents intelligently for downstream processing"],"best_for":["researchers processing academic papers","teams extracting requirements from technical documents","developers building document-based code generation pipelines"],"limitations":["PDF parsing may fail on scanned documents (images); OCR not built-in","Document segmentation uses heuristics; complex layouts (multi-column, tables) may segment incorrectly","arXiv API has rate limits; batch processing large numbers of papers may timeout","DOCX parsing preserves basic formatting but loses complex styles and embedded objects"],"requires":["Python 3.9+","PyPDF2 or similar PDF library","python-docx for DOCX support","requests library for arXiv API","Network access to arXiv (for URL-based input)"],"input_types":["PDF files","DOCX files","plain text files","arXiv URLs (e.g., arxiv.org/abs/2512.07921)"],"output_types":["extracted text (plain text)","structured content (JSON with sections/headings)","segmented chunks (list of text segments)","metadata (title, authors, abstract)"],"categories":["data-processing-analysis","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":42,"verified":false,"data_access_risk":"high","permissions":["Python 3.9+","MCP server implementation (provided in mcp_agent.config.yaml)","LLM provider API keys (OpenAI, Anthropic, or compatible)","Model Context Protocol client library","PDF parsing library (PyPDF2 or similar)","arXiv API access for paper fetching","LLM with 8k+ token context window","LLM provider API keys","Logging infrastructure for error reporting","Timeout configuration (default: 60 seconds)"],"failure_modes":["MCP overhead adds latency per agent handoff (~100-300ms depending on tool complexity)","No built-in agent failure recovery — requires external orchestration layer for resilience","Agent state synchronization relies on explicit context passing; no implicit shared memory between agents","Accuracy depends on paper clarity — dense mathematical notation may require manual clarification","Document segmentation uses heuristic boundaries; complex multi-section papers may need custom chunking strategies","Generated code requires human review for production use; no formal verification of algorithmic correctness","Retry logic adds latency (exponential backoff can exceed 1 minute for persistent failures)","Context window overflow handling requires fallback strategies (chunking, summarization) that may degrade output quality","Provider-specific error codes are not fully standardized; some errors may not be retried correctly","No built-in circuit breaker; repeated failures will continue retrying until timeout","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.714209633530048,"quality":0.25,"ecosystem":0.46,"match_graph":0.25,"freshness":0.5,"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":"inactive","updated_at":"2026-05-06T15:12:23.810Z","last_scraped_at":"2026-05-03T13:57:11.504Z","last_commit":"2026-04-30T20:16:51Z"},"community":{"stars":15307,"forks":2044,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=hkuds--deepcode","compare_url":"https://unfragile.ai/compare?artifact=hkuds--deepcode"}},"signature":"ne/n8dKAaY51dShL6tkwWxhqJkCvC5/IgvfAn/YFtrTYIu6hYzu/0VRCbdNepG5abydXNJXfcvXR5VffXZgCCQ==","signedAt":"2026-06-20T17:34:32.283Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/hkuds--deepcode","artifact":"https://unfragile.ai/hkuds--deepcode","verify":"https://unfragile.ai/api/v1/verify?slug=hkuds--deepcode","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"}}