{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-hkuds--nanobot","slug":"hkuds--nanobot","name":"nanobot","type":"agent","url":"https://nanobot.wiki","page_url":"https://unfragile.ai/hkuds--nanobot","categories":["ai-agents"],"tags":["ai","ai-agent","ai-agents","anthropic","chatgpt","claude","claude-code","codex","llm","nanobot","openai","openclaw"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-hkuds--nanobot__cap_0","uri":"capability://tool.use.integration.multi.channel.agent.deployment.with.unified.message.routing","name":"multi-channel agent deployment with unified message routing","description":"Nanobot implements a BaseChannel abstraction layer that normalizes message I/O across 25+ messaging platforms (Telegram, Feishu, Matrix, Discord, WeChat, Slack) and a CLI REPL, routing all user inputs through a centralized message bus and event flow system. Each channel adapter handles platform-specific authentication, message formatting, and delivery semantics while the core AgentLoop processes normalized message objects, enabling a single agent instance to serve multiple communication channels simultaneously without code duplication.","intents":["Deploy a single AI agent across multiple chat platforms without rewriting core logic","Add support for a new messaging platform without modifying the agent engine","Route messages from Telegram, Slack, and Matrix to the same agent instance","Build a CLI REPL interface for local development while keeping production channels in sync"],"best_for":["teams building multi-platform AI assistants","developers wanting to support both chat apps and CLI without code duplication","organizations migrating between communication platforms"],"limitations":["Channel-specific features (rich media, interactive buttons) require custom adapter implementation","Message ordering guarantees depend on underlying platform semantics — eventual consistency model","No built-in message deduplication across channels — requires application-level handling for cross-channel broadcasts"],"requires":["Python 3.9+","Platform-specific API credentials (Telegram token, Feishu app ID, Matrix homeserver URL, etc.)","nanobot package with channel plugins installed"],"input_types":["text messages","structured message metadata (sender ID, timestamp, thread context)"],"output_types":["text responses","platform-native formatted messages","structured event objects"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--nanobot__cap_1","uri":"capability://tool.use.integration.provider.agnostic.llm.abstraction.with.auto.detection.and.registry","name":"provider-agnostic llm abstraction with auto-detection and registry","description":"Nanobot implements a ProviderSpec registry pattern that abstracts 25+ LLM services (OpenAI, Anthropic, Ollama, Groq, etc.) behind a unified interface. The system uses native SDKs for major providers (OpenAI, Anthropic) and a centralized metadata registry for auto-detection of model capabilities, token limits, and cost parameters. Provider selection is declarative via config schema, with fallback logic for API key resolution from environment variables or config files, enabling seamless switching between LLM backends without code changes.","intents":["Switch between OpenAI GPT-4, Claude, and Ollama without modifying agent code","Auto-detect which LLM provider to use based on available API keys","Support cost-aware provider selection based on model pricing metadata","Extend the system with custom LLM providers via the registry pattern"],"best_for":["developers building LLM-agnostic applications","teams evaluating multiple LLM providers in production","organizations wanting to avoid vendor lock-in"],"limitations":["Provider-specific features (vision, function calling schemas) require adapter-level normalization — not all providers support all capabilities","Token counting is approximate for non-OpenAI providers — actual usage may vary","Streaming behavior differs across providers — buffering and timeout handling must be provider-aware"],"requires":["Python 3.9+","API keys for at least one supported LLM provider (OpenAI, Anthropic, Ollama, Groq, etc.)","nanobot package with provider plugins"],"input_types":["model name string","provider configuration object","API key credentials"],"output_types":["LLM response text","structured completion objects","streaming token streams"],"categories":["tool-use-integration","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--nanobot__cap_10","uri":"capability://automation.workflow.declarative.yaml.configuration.with.schema.validation.and.env.interpolation","name":"declarative yaml configuration with schema validation and env interpolation","description":"Nanobot uses a declarative YAML configuration schema (defined in config/schema.py) that specifies agent behavior, LLM provider, channels, tools, memory settings, and automation rules. The configuration loader supports environment variable interpolation (e.g., ${OPENAI_API_KEY}), schema validation via Pydantic, and config migration/backfilling for backward compatibility. Configuration is loaded at startup and can be reloaded without restarting the agent, enabling dynamic reconfiguration.","intents":["Configure agent behavior without modifying code","Switch LLM providers or channels via config changes","Manage API keys and secrets via environment variables","Validate configuration at startup to catch errors early"],"best_for":["developers wanting configuration-driven agent setup","teams managing multiple agent instances with different configs","applications requiring dynamic reconfiguration"],"limitations":["YAML syntax errors are caught at load time — no schema-aware IDE support","Environment variable interpolation is simple string replacement — no type coercion","Config migration is manual — breaking changes require explicit migration logic","No built-in config versioning — tracking config changes requires external tools"],"requires":["Python 3.9+","YAML configuration file","Environment variables for secrets (optional)"],"input_types":["YAML configuration file","environment variables"],"output_types":["validated configuration object","agent instance"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--nanobot__cap_11","uri":"capability://automation.workflow.cli.repl.with.command.routing.and.interactive.agent.interaction","name":"cli repl with command routing and interactive agent interaction","description":"Nanobot provides a feature-rich CLI REPL (built with typer and prompt-toolkit) that enables interactive agent interaction with command routing, history, autocomplete, and syntax highlighting. The CLI supports built-in commands (e.g., /memory, /tools, /config) for agent introspection and control, while regular text is routed to the agent for processing. The REPL maintains conversation history and integrates with the agent's session management, allowing users to interact with the agent from the terminal.","intents":["Interact with agents from the command line during development","Inspect agent state, memory, and available tools","Test agent behavior before deploying to production channels","Debug agent issues with built-in introspection commands"],"best_for":["developers testing agents locally","teams debugging agent behavior","users wanting a terminal-based agent interface"],"limitations":["REPL is single-user — no support for concurrent interactions","History is in-memory — lost on REPL exit","No built-in multi-turn conversation tracking — each message is independent","Command syntax is custom — not compatible with standard shell commands"],"requires":["Python 3.9+","Terminal with ANSI color support","nanobot package with CLI dependencies"],"input_types":["user text input","CLI commands"],"output_types":["agent response text","command output","formatted agent state"],"categories":["automation-workflow","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--nanobot__cap_12","uri":"capability://automation.workflow.docker.containerization.and.multi.instance.deployment","name":"docker containerization and multi-instance deployment","description":"Nanobot supports Docker containerization via a Dockerfile that packages the agent with all dependencies, enabling consistent deployment across environments. The system supports multi-instance deployment where multiple agent instances can run concurrently (e.g., in Kubernetes), each with its own configuration and session state. The message bus and channel layer coordinate across instances, and external storage (database, Redis) can be used for shared state (sessions, memory, configuration).","intents":["Deploy agents in containerized environments (Docker, Kubernetes)","Scale agents horizontally by running multiple instances","Ensure consistent behavior across development, staging, and production","Manage agent dependencies and versions via container images"],"best_for":["teams deploying agents in cloud environments","applications requiring horizontal scaling","organizations wanting reproducible deployments"],"limitations":["Multi-instance deployment requires external state store — no built-in distributed state","Session affinity is not guaranteed — requests may route to different instances","Memory consolidation is per-instance — no cross-instance memory sharing","Container startup time includes agent initialization — no warm-start optimization"],"requires":["Docker or container runtime","External state store for shared state (Redis, database)","Container orchestration platform (Kubernetes, Docker Compose, etc.)"],"input_types":["Dockerfile","agent configuration","environment variables"],"output_types":["container image","running agent instance"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--nanobot__cap_13","uri":"capability://safety.moderation.security.and.sandboxing.with.path.validation.and.command.whitelisting","name":"security and sandboxing with path validation and command whitelisting","description":"Nanobot implements security controls at the tool layer: file operations are restricted to configured directories via path validation, shell commands can be whitelisted to prevent arbitrary execution, and network requests can be filtered by URL patterns. The security layer validates all tool inputs before execution and logs security events for audit trails. Network security includes configurable headers, timeout limits, and SSL verification to prevent SSRF and other attacks.","intents":["Prevent agents from accessing files outside configured directories","Restrict shell execution to whitelisted commands","Prevent SSRF attacks by validating URLs","Audit security events for compliance and debugging"],"best_for":["developers deploying agents in multi-tenant environments","teams with strict security requirements","applications handling sensitive data"],"limitations":["Security controls are tool-level — no process-level isolation","Whitelisting is static — no dynamic rule updates without restart","Path validation is string-based — symlink attacks are possible","No built-in rate limiting — agents can exhaust resources"],"requires":["Python 3.9+","Security configuration in agent config","Careful configuration of allowed paths and commands"],"input_types":["file paths","shell commands","URLs"],"output_types":["validation results","security events","audit logs"],"categories":["safety-moderation","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--nanobot__cap_14","uri":"capability://planning.reasoning.subagent.orchestration.and.multi.agent.communication","name":"subagent orchestration and multi-agent communication","description":"Nanobot supports creating subagents that can be spawned by parent agents to handle specialized tasks. Subagents are configured similarly to parent agents (with their own LLM provider, tools, memory) and communicate with parent agents via the message bus. Parent agents can delegate tasks to subagents, wait for results, and incorporate subagent responses into their own reasoning. This enables hierarchical agent structures where complex tasks are decomposed across multiple specialized agents.","intents":["Decompose complex tasks across multiple specialized agents","Create hierarchical agent structures with parent-child relationships","Enable agents to delegate work to subagents and wait for results","Build agent teams that collaborate on multi-step tasks"],"best_for":["developers building complex multi-agent systems","applications requiring task specialization","teams wanting to decompose agent responsibilities"],"limitations":["Subagent communication is synchronous — parent agents block waiting for results","No built-in load balancing — subagent selection is manual","Subagent state is isolated — no shared memory between agents","No automatic task decomposition — parent agents must explicitly delegate"],"requires":["Python 3.9+","Subagent configuration","Message bus for inter-agent communication"],"input_types":["task description","subagent configuration"],"output_types":["subagent response","task results"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--nanobot__cap_2","uri":"capability://planning.reasoning.agent.loop.with.configurable.tool.iteration.limits.and.context.building","name":"agent loop with configurable tool iteration limits and context building","description":"The AgentLoop orchestrates the core agent execution cycle: it receives a user message, builds context from memory and session history, sends a prompt to the LLM, parses tool calls from the response, executes tools, and loops until the agent decides to respond or hits a configurable iteration limit (default 200 iterations). Context building dynamically incorporates session history, memory consolidation results, and available tool schemas, with each iteration step tracked for debugging and memory consolidation.","intents":["Execute multi-step reasoning tasks where the agent calls tools iteratively","Prevent infinite loops by enforcing maximum iteration limits","Debug agent behavior by inspecting each loop iteration and tool call","Build context that includes relevant memory and session history for each LLM query"],"best_for":["developers building autonomous agents with tool use","teams needing visibility into agent decision-making","applications requiring bounded execution time"],"limitations":["Iteration limit is global — no per-tool timeout or resource limits","Context building is synchronous — large session histories can cause latency","No built-in backtracking or recovery from tool failures — agent must handle errors via tool responses"],"requires":["Python 3.9+","Configured LLM provider with tool-calling support","At least one tool registered in the agent's tool registry"],"input_types":["user message text","session context object","tool registry"],"output_types":["agent response text","iteration history with tool calls and results","memory consolidation events"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--nanobot__cap_3","uri":"capability://memory.knowledge.two.tier.memory.system.with.session.history.and.dream.consolidation","name":"two-tier memory system with session history and dream consolidation","description":"Nanobot implements a two-tier memory architecture: session-based history stores recent interactions in memory, while a 'Dream' consolidation process periodically compresses history into long-term facts via LLM summarization. The DreamConfig defines consolidation triggers (time-based, message-count-based, or manual), and the system maintains separate storage for raw history and consolidated facts, allowing agents to retain context over long conversations without unbounded token growth.","intents":["Maintain conversation context across multiple sessions without token explosion","Automatically summarize long conversation histories into key facts","Trigger memory consolidation based on time, message count, or manual signals","Retrieve relevant historical context for new queries using consolidated facts"],"best_for":["developers building long-running personal AI assistants","applications with users who have extended conversations","teams wanting to reduce LLM token costs over time"],"limitations":["Dream consolidation is lossy — fine-grained details are compressed into summaries","No built-in persistence layer — requires external state store (database, file system)","Consolidation timing is configurable but not adaptive — no automatic tuning based on conversation patterns","No multi-agent memory sharing — each agent instance maintains separate memory"],"requires":["Python 3.9+","Configured LLM provider for summarization","External storage backend for session history and consolidated facts"],"input_types":["conversation messages","consolidation trigger signals"],"output_types":["session history list","consolidated fact summaries","memory metadata (timestamps, token counts)"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--nanobot__cap_4","uri":"capability://tool.use.integration.built.in.tool.system.with.shell.file.and.web.capabilities","name":"built-in tool system with shell, file, and web capabilities","description":"Nanobot provides a built-in tool registry with three core tools: shell execution (subprocess-based command running), file operations (read/write/list with path validation), and web access (HTTP requests with configurable headers and timeouts). Tools are registered as callable functions with JSON schema definitions, enabling the LLM to invoke them via tool-calling APIs. Each tool includes safety checks (path validation for files, command whitelisting for shell) and error handling that returns structured results to the agent.","intents":["Allow agents to execute shell commands and capture output","Enable agents to read and write files with path-based access control","Permit agents to fetch web content and parse responses","Extend the agent with custom tools by registering new callables"],"best_for":["developers building autonomous agents that need system access","applications requiring file manipulation or web scraping","teams wanting a safe, sandboxed tool execution environment"],"limitations":["Shell execution runs in the agent's process context — no process isolation or resource limits","File operations are path-validated but not containerized — access is limited to configured directories","Web tool has no built-in caching — repeated requests hit the network","Tool schemas are manually defined — no automatic schema generation from function signatures"],"requires":["Python 3.9+","Configured tool registry in agent config","File system permissions for file tool","Network access for web tool"],"input_types":["tool name string","tool arguments object (command, file path, URL, etc.)"],"output_types":["command output text","file contents","HTTP response body","structured error objects"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--nanobot__cap_5","uri":"capability://tool.use.integration.model.context.protocol.mcp.integration.with.stdio.and.http.transports","name":"model context protocol (mcp) integration with stdio and http transports","description":"Nanobot integrates with the Model Context Protocol (MCP) standard, allowing agents to dynamically load external tools via stdio or HTTP transports. The MCP integration layer handles protocol negotiation, tool discovery, and invocation, enabling agents to access tools from external services (e.g., Anthropic's MCP servers) without modifying core agent code. Tools discovered via MCP are registered in the same tool registry as built-in tools, making them transparent to the agent loop.","intents":["Connect agents to external MCP-compatible tool servers","Dynamically discover and invoke tools from remote services","Extend agent capabilities without modifying the agent codebase","Use Anthropic's MCP servers (filesystem, web, git, etc.) with nanobot agents"],"best_for":["developers building extensible agent systems","teams using Anthropic's MCP ecosystem","applications needing dynamic tool discovery"],"limitations":["MCP protocol overhead adds latency per tool invocation (~50-200ms depending on transport)","Stdio transport requires subprocess management — no built-in process pooling","HTTP transport requires network connectivity and authentication handling","Tool schema negotiation is synchronous — large tool sets can slow agent startup"],"requires":["Python 3.9+","MCP-compatible tool server (stdio or HTTP endpoint)","nanobot MCP integration module"],"input_types":["MCP server endpoint (stdio command or HTTP URL)","tool invocation requests"],"output_types":["discovered tool schemas","tool execution results","MCP protocol messages"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--nanobot__cap_6","uri":"capability://automation.workflow.cron.based.automation.and.scheduled.task.execution","name":"cron-based automation and scheduled task execution","description":"Nanobot includes a Cron Service that enables agents to schedule recurring tasks using cron expressions (e.g., '0 9 * * *' for daily 9 AM execution). The service maintains a schedule registry, triggers tasks at specified times, and invokes agent callbacks (AgentHook lifecycle callbacks) to execute custom logic. Scheduled tasks can invoke tools, send messages to channels, or trigger memory consolidation, enabling agents to perform background work without user interaction.","intents":["Schedule agents to run periodic tasks (daily reports, hourly checks, etc.)","Trigger memory consolidation on a schedule","Send proactive messages to users at specific times","Implement background monitoring or data collection tasks"],"best_for":["developers building always-on AI assistants","applications requiring periodic background tasks","teams wanting to automate routine agent actions"],"limitations":["Cron scheduling is local to the agent instance — no distributed scheduling across multiple instances","No built-in task persistence — scheduled tasks are lost if the agent restarts","Cron expressions are limited to standard syntax — no custom scheduling logic","Task execution is blocking — long-running tasks can delay other scheduled tasks"],"requires":["Python 3.9+","Cron expression syntax knowledge","Agent instance running continuously"],"input_types":["cron expression string","task callback function"],"output_types":["task execution results","scheduled task metadata"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--nanobot__cap_7","uri":"capability://automation.workflow.heartbeat.service.for.connection.monitoring.and.keep.alive","name":"heartbeat service for connection monitoring and keep-alive","description":"Nanobot implements a Heartbeat Service that periodically sends keep-alive signals to connected channels and monitors connection health. The service detects disconnections, triggers reconnection logic, and maintains session continuity across network interruptions. Heartbeat intervals are configurable per channel, and the service integrates with the message bus to coordinate health checks across multiple concurrent channel connections.","intents":["Detect and recover from channel disconnections automatically","Maintain persistent connections to messaging platforms","Monitor agent health and availability","Implement graceful degradation when channels become unavailable"],"best_for":["developers building always-on multi-channel agents","applications requiring high availability","teams deploying agents in unreliable network environments"],"limitations":["Heartbeat is local to the agent instance — no distributed health monitoring","Reconnection logic is channel-specific — not all channels support graceful reconnection","Heartbeat intervals are static — no adaptive tuning based on network conditions","No built-in alerting — health status must be monitored externally"],"requires":["Python 3.9+","Channel implementations with heartbeat support","Network connectivity to messaging platforms"],"input_types":["heartbeat interval configuration","channel connection objects"],"output_types":["health status signals","reconnection events","connection metadata"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--nanobot__cap_8","uri":"capability://automation.workflow.session.lifecycle.management.with.state.tracking.and.cleanup","name":"session lifecycle management with state tracking and cleanup","description":"Nanobot manages session lifecycles by tracking session state (active, idle, closed), maintaining session metadata (creation time, last activity, user context), and implementing cleanup logic for expired sessions. Sessions are created per user or conversation thread, and the system tracks session state transitions through the message bus. Expired sessions trigger memory consolidation and cleanup callbacks, enabling graceful session termination and resource reclamation.","intents":["Track conversation state across multiple messages and sessions","Implement session timeouts and automatic cleanup","Trigger memory consolidation when sessions end","Maintain per-user or per-conversation context"],"best_for":["developers building multi-user AI assistants","applications requiring per-conversation state management","teams wanting to implement session-based billing or analytics"],"limitations":["Session state is in-memory — no distributed session management across multiple agent instances","Session cleanup is local — no coordination with external session stores","Session timeout is static — no adaptive tuning based on user activity patterns","No built-in session persistence — sessions are lost on agent restart"],"requires":["Python 3.9+","Session configuration in agent config","External storage for session persistence (optional)"],"input_types":["user or conversation identifier","session metadata object"],"output_types":["session state object","session lifecycle events","cleanup signals"],"categories":["automation-workflow","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-hkuds--nanobot__cap_9","uri":"capability://tool.use.integration.python.sdk.with.programmatic.agent.embedding.and.lifecycle.hooks","name":"python sdk with programmatic agent embedding and lifecycle hooks","description":"Nanobot provides a high-level Python SDK (Nanobot.from_config()) that enables embedding agents into Python applications without CLI overhead. The SDK exposes AgentHook lifecycle callbacks for custom logic at key points (agent startup, message processing, tool invocation, memory consolidation), allowing developers to integrate agents into larger systems. The SDK returns a Nanobot facade object with methods for sending messages, querying state, and managing the agent lifecycle programmatically.","intents":["Embed nanobot agents into Python applications","Hook into agent lifecycle events for custom logic","Send messages to agents programmatically","Query agent state and memory from application code"],"best_for":["developers building Python applications with embedded AI agents","teams integrating nanobot into larger systems","applications requiring programmatic agent control"],"limitations":["SDK is Python-only — no support for other languages","Lifecycle hooks are synchronous — long-running hooks can block agent processing","No built-in async support — blocking I/O in hooks can cause latency","SDK state is in-process — no distributed state sharing"],"requires":["Python 3.9+","nanobot package installed","Agent configuration file or dict"],"input_types":["agent configuration","message text","lifecycle callback functions"],"output_types":["Nanobot facade object","agent response text","agent state objects"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":51,"verified":false,"data_access_risk":"high","permissions":["Python 3.9+","Platform-specific API credentials (Telegram token, Feishu app ID, Matrix homeserver URL, etc.)","nanobot package with channel plugins installed","API keys for at least one supported LLM provider (OpenAI, Anthropic, Ollama, Groq, etc.)","nanobot package with provider plugins","YAML configuration file","Environment variables for secrets (optional)","Terminal with ANSI color support","nanobot package with CLI dependencies","Docker or container runtime"],"failure_modes":["Channel-specific features (rich media, interactive buttons) require custom adapter implementation","Message ordering guarantees depend on underlying platform semantics — eventual consistency model","No built-in message deduplication across channels — requires application-level handling for cross-channel broadcasts","Provider-specific features (vision, function calling schemas) require adapter-level normalization — not all providers support all capabilities","Token counting is approximate for non-OpenAI providers — actual usage may vary","Streaming behavior differs across providers — buffering and timeout handling must be provider-aware","YAML syntax errors are caught at load time — no schema-aware IDE support","Environment variable interpolation is simple string replacement — no type coercion","Config migration is manual — breaking changes require explicit migration logic","No built-in config versioning — tracking config changes requires external tools","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.8262619022915794,"quality":0.35,"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.550Z","last_scraped_at":"2026-05-03T13:57:04.027Z","last_commit":"2026-05-02T17:03:22Z"},"community":{"stars":41554,"forks":7300,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=hkuds--nanobot","compare_url":"https://unfragile.ai/compare?artifact=hkuds--nanobot"}},"signature":"fWzeungZ8gx1MZG5lhWMdjs7AEGZX8VLJBiZ43Gd1Yclxvss3ITRbCBQDuomqUfwERupYHKAHEXeYuZ7/57NDg==","signedAt":"2026-06-21T18:32:12.367Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/hkuds--nanobot","artifact":"https://unfragile.ai/hkuds--nanobot","verify":"https://unfragile.ai/api/v1/verify?slug=hkuds--nanobot","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"}}