{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-holaboss-ai--holaos","slug":"holaboss-ai--holaos","name":"holaOS","type":"agent","url":"https://holaos.ai","page_url":"https://unfragile.ai/holaboss-ai--holaos","categories":["ai-agents"],"tags":["agent","agent-harness","agent-os","agentic","ai","ai-agent","ai-agents","artificial-intelligence","electron","holaboss","holaos","llm","mcp","memory","model-context-protocol","proactive","proactive-ai","runtime","typescript","workspace"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-holaboss-ai--holaos__cap_0","uri":"capability://planning.reasoning.environment.engineered.agent.execution.with.durable.workspace.state","name":"environment-engineered agent execution with durable workspace state","description":"Executes agents within a structured workspace environment that persists state across sessions, using a three-layer architecture (Desktop UI → Runtime API Server → Agent Harness) that decouples the operator interface from execution logic. The runtime manages agent lifecycle via SQLite-backed state store and compiles 'Run Plans' that define agent behavior as environment contracts rather than hard-coded harness logic, enabling agents to evolve their own execution patterns based on workspace structure.","intents":["I need agents that maintain context and memory across multiple sessions without losing state","I want to define agent capabilities through environment structure rather than model-specific prompts","I need to swap agent implementations (harnesses) without rewriting the entire agent system","I want agents to self-evolve by modifying their own workspace and execution patterns"],"best_for":["teams building long-horizon autonomous agents that require session persistence","developers implementing multi-session agent workflows with complex state management","organizations wanting environment-driven rather than model-driven agent behavior definition"],"limitations":["Requires local runtime deployment — no cloud-native multi-tenant isolation built-in","State store is SQLite-based, limiting horizontal scaling across multiple machines","Agent harness swapping requires compatible MCP interface implementations","Environment engineering paradigm has steeper learning curve than traditional prompt-based agents"],"requires":["Node.js 18+ for runtime and desktop application","TypeScript for app development (Bridge SDK and App SDK)","Local HTTP server capability (runtime API server on port 5160)","SQLite support for state persistence"],"input_types":["natural language instructions","workspace configuration (YAML manifests)","MCP tool definitions","agent run plans (compiled execution specifications)"],"output_types":["agent execution traces","workspace state snapshots","memory recall results","run completion reports with state deltas"],"categories":["planning-reasoning","automation-workflow","agent-runtime"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-holaboss-ai--holaos__cap_1","uri":"capability://tool.use.integration.mcp.based.tool.integration.and.capability.projection","name":"mcp-based tool integration and capability projection","description":"Manages Model Context Protocol (MCP) tool servers as the primary mechanism for projecting agent capabilities into the runtime environment. The runtime hosts MCP servers, maintains their lifecycle, and exposes tools through a schema-based function registry that agents can discover and invoke. Tools are defined declaratively in app.runtime.yaml manifests and integrated via Bridge SDK, enabling dynamic capability composition without modifying core agent logic.","intents":["I need to expose external tools and APIs to agents through a standardized protocol","I want agents to discover available capabilities dynamically at runtime","I need to add new tools without redeploying the entire agent system","I want to manage tool lifecycle (startup, shutdown, error handling) automatically"],"best_for":["developers building extensible agent systems with pluggable tool ecosystems","teams integrating multiple external APIs and services into agent workflows","organizations standardizing on MCP for agent-tool communication"],"limitations":["MCP server lifecycle management is runtime-specific — no cross-runtime tool sharing","Tool schema validation relies on MCP spec compliance; malformed schemas cause runtime errors","No built-in tool versioning or backward compatibility management","Tool invocation latency includes MCP serialization/deserialization overhead"],"requires":["MCP server implementation (can be any language with MCP SDK)","app.runtime.yaml manifest defining tool schemas and server configuration","Bridge SDK (@holaboss/bridge) for tool registration in TypeScript apps","Runtime API server running to host MCP server processes"],"input_types":["MCP tool schema definitions (JSON Schema format)","app.runtime.yaml manifest with tool server configuration","tool invocation requests from agent with parameters"],"output_types":["tool execution results","tool schema discovery responses","tool availability status and error messages"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-holaboss-ai--holaos__cap_10","uri":"capability://planning.reasoning.multi.model.agent.harness.abstraction.with.swappable.implementations","name":"multi-model agent harness abstraction with swappable implementations","description":"Abstracts agent execution logic behind a swappable 'Agent Harness' interface that decouples the runtime environment from specific LLM implementations or agent reasoning patterns. Different harness implementations can be plugged in (e.g., ReAct pattern, tool-use agents, planning-based agents) without modifying the runtime, enabling multi-model support and experimentation with different agent architectures.","intents":["I need to swap between different agent implementations without redeploying the runtime","I want to experiment with different agent reasoning patterns (ReAct, planning, etc.)","I need to support multiple LLM providers without runtime changes","I want to implement custom agent harnesses for specialized use cases"],"best_for":["teams experimenting with different agent architectures and reasoning patterns","organizations supporting multiple LLM providers (OpenAI, Anthropic, local models)","developers implementing custom agent harnesses for specialized domains"],"limitations":["Harness interface is runtime-specific; no standard harness interface across frameworks","Harness swapping requires compatible MCP tool interface; incompatible tools cause failures","No built-in harness performance benchmarking or comparison tools","Harness selection is workspace-scoped; no per-run harness selection"],"requires":["Agent Harness interface implementation","MCP tool compatibility for selected harness","Workspace configuration specifying active harness","Runtime support for harness lifecycle management"],"input_types":["harness implementation (code or configuration)","agent instructions and workspace context","MCP tool definitions"],"output_types":["agent execution results","harness-specific execution traces","reasoning patterns and decision logs"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-holaboss-ai--holaos__cap_11","uri":"capability://tool.use.integration.runtime.api.server.with.fastify.based.http.interface","name":"runtime api server with fastify-based http interface","description":"Exposes runtime functionality through a Fastify-based HTTP API server (typically port 5160) that handles workspace management, run compilation, tool invocation, memory recall, and state queries. The API server is the primary integration point for external clients (desktop application, custom tools, third-party systems) and provides RESTful endpoints for all runtime operations.","intents":["I need to integrate holaOS runtime with external systems via HTTP API","I want to programmatically trigger agent execution from custom applications","I need to query agent state and memory through standard HTTP endpoints","I want to build custom clients or integrations with the runtime"],"best_for":["developers building custom integrations with holaOS runtime","teams embedding holaOS runtime in larger systems","organizations needing programmatic access to agent execution and state"],"limitations":["HTTP API adds network latency compared to in-process runtime access","No built-in API authentication or authorization; relies on network isolation","API rate limiting is not implemented; no built-in throttling for high-volume requests","API schema is not formally documented (OpenAPI/Swagger); clients must reverse-engineer endpoints"],"requires":["Fastify 4+ for HTTP server","Node.js 18+ for runtime","Network access to port 5160 (or configured API port)","HTTP client library for API consumption"],"input_types":["HTTP requests with JSON payloads","workspace context and configuration","agent execution parameters"],"output_types":["JSON responses with execution results","state snapshots and memory recall results","error responses with diagnostic information"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-holaboss-ai--holaos__cap_12","uri":"capability://data.processing.analysis.sqlite.backed.state.store.with.workspace.scoped.data.partitioning","name":"sqlite-backed state store with workspace-scoped data partitioning","description":"Uses SQLite as the primary persistence layer for all runtime state including workspace configuration, agent execution history, memory surfaces, and run plans. The state store implements workspace-scoped data partitioning, enabling logical isolation of state across workspaces while maintaining a single SQLite database. State queries and updates are synchronous, providing immediate consistency for agent execution.","intents":["I need persistent storage for agent state, memory, and execution history","I want to query historical agent execution and performance metrics","I need to maintain separate state contexts for different workspaces","I want to audit and inspect agent state changes over time"],"best_for":["teams requiring local, persistent state management without external databases","developers building agents with audit and compliance requirements","organizations needing workspace-scoped state isolation"],"limitations":["SQLite is single-machine only; no distributed state management or replication","Synchronous state operations can block agent execution if queries are slow","No built-in state backup or disaster recovery mechanisms","State store schema is runtime-specific; no standard schema for agent state"],"requires":["SQLite 3.35+ for state store","Database file path accessible to runtime process","Schema migration system for state store updates","Write access to database file for state persistence"],"input_types":["state update requests from runtime","state queries from agents or clients","workspace context for data partitioning"],"output_types":["persisted state snapshots","query results with historical data","state change audit logs"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-holaboss-ai--holaos__cap_2","uri":"capability://memory.knowledge.durable.memory.and.continuity.with.recall.based.context.injection","name":"durable memory and continuity with recall-based context injection","description":"Implements a memory system that persists agent observations, decisions, and learned patterns across sessions using the state store (SQLite). Memory surfaces are exposed through the workspace model, and agents can recall relevant context during execution via memory recall mechanisms that inject historical state into the current run plan. This enables agents to maintain continuity of knowledge and adapt behavior based on past interactions without explicit prompt engineering.","intents":["I need agents to remember past interactions and decisions across multiple sessions","I want agents to learn patterns from historical execution and adapt their behavior","I need to provide agents with relevant context from past runs without manual prompt construction","I want to audit and inspect agent memory to understand decision-making patterns"],"best_for":["teams building agents that improve over time through accumulated experience","developers implementing agents with long-term user relationships requiring context continuity","organizations needing audit trails of agent reasoning and learned patterns"],"limitations":["Memory recall is SQLite-based and not optimized for semantic similarity search — requires manual query specification","No built-in memory pruning or forgetting mechanisms; memory grows unbounded over time","Memory injection into run plans adds latency proportional to historical data volume","Memory surfaces are workspace-scoped; no cross-workspace memory sharing or federation"],"requires":["SQLite state store with schema supporting memory table definitions","Memory surface definitions in workspace configuration","Agent harness implementation that supports memory recall during run plan execution","Mechanism to serialize and deserialize memory state (typically JSON)"],"input_types":["agent observations and execution traces","memory query specifications (workspace-defined)","historical state snapshots"],"output_types":["recalled memory context injected into run plans","memory audit logs","learned pattern summaries"],"categories":["memory-knowledge","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-holaboss-ai--holaos__cap_3","uri":"capability://planning.reasoning.run.plan.compilation.and.agent.execution.orchestration","name":"run plan compilation and agent execution orchestration","description":"Compiles natural language agent instructions into 'Run Plans' — structured execution specifications that define the sequence of agent actions, tool invocations, and state transitions. The runtime's run compilation system translates user intent from natural language space into code entity space (runtime processes and state), managing the full lifecycle of agent execution including tool invocation sequencing, error handling, and state persistence. Run plans are executable specifications that can be inspected, modified, and replayed.","intents":["I need to translate high-level agent instructions into executable, inspectable execution plans","I want to understand what actions an agent will take before execution (plan inspection)","I need to replay or modify agent execution plans for debugging or optimization","I want to compose complex multi-step agent workflows with conditional branching and error handling"],"best_for":["developers building agents with complex, multi-step workflows requiring plan visibility","teams needing to audit and inspect agent execution plans before deployment","organizations implementing agent debugging and optimization workflows"],"limitations":["Run plan compilation is synchronous and blocks until plan is fully compiled","No built-in plan optimization or cost estimation before execution","Plan modification after compilation requires recompilation; no incremental plan updates","Plan serialization format is runtime-specific; no standard interchange format defined"],"requires":["Agent harness implementation supporting run plan execution","Natural language input from user or upstream system","Runtime API server with run compilation endpoint","State store access for persisting compiled plans"],"input_types":["natural language instructions","workspace context and available tools","agent harness configuration"],"output_types":["compiled run plan (structured execution specification)","execution trace with tool invocations and state transitions","run completion report with final state"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-holaboss-ai--holaos__cap_4","uri":"capability://automation.workflow.workspace.scoped.configuration.and.capability.isolation","name":"workspace-scoped configuration and capability isolation","description":"Organizes agent environments into isolated workspaces that encapsulate configuration, tools, memory surfaces, and execution context. Workspaces are defined through app.runtime.yaml manifests and managed by the desktop application, providing a structural boundary for agent capabilities and state. Each workspace maintains its own tool registry, memory store, and execution context, enabling multi-tenant or multi-project isolation within a single holaOS instance.","intents":["I need to isolate agent environments for different projects or use cases","I want to configure different tool sets and capabilities per workspace","I need to manage separate memory and state contexts for different agents or teams","I want to switch between agent configurations without affecting other running agents"],"best_for":["teams managing multiple agent projects with different tool requirements","organizations needing workspace-level isolation for multi-tenant scenarios","developers building modular agent systems with pluggable workspace configurations"],"limitations":["Workspace isolation is logical, not cryptographic — no security boundary enforcement","No built-in workspace sharing or collaboration features","Workspace switching requires desktop application interaction; no programmatic workspace API","State store is single-instance; workspace isolation relies on logical partitioning, not separate databases"],"requires":["app.runtime.yaml manifest defining workspace configuration","Desktop application for workspace creation and management","Runtime API server with workspace context support","State store with workspace-scoped table partitioning"],"input_types":["app.runtime.yaml workspace manifest","workspace configuration parameters","tool and capability definitions"],"output_types":["workspace context and active configuration","workspace-scoped tool registry","workspace memory and state snapshots"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-holaboss-ai--holaos__cap_5","uri":"capability://automation.workflow.electron.based.desktop.application.with.ipc.bridged.runtime.communication","name":"electron-based desktop application with ipc-bridged runtime communication","description":"Provides an Electron-based desktop shell (operator-facing UI) that communicates with the embedded runtime via a type-safe IPC bridge (window.electronAPI) and local HTTP server (typically port 5160). The desktop application handles workspace creation, model configuration, agent progress visualization, and workspace switching. The IPC bridge abstracts runtime communication, enabling the desktop to invoke runtime operations and receive state updates without direct HTTP coupling.","intents":["I need a visual interface to create, configure, and monitor agent workspaces","I want to switch between agent configurations and view execution progress in real-time","I need to manage model selection and API credentials through a desktop UI","I want to inspect agent state and memory through a visual workspace browser"],"best_for":["non-technical operators managing agent workspaces through visual UI","developers prototyping and debugging agent configurations locally","teams needing visual workspace management without CLI-only interfaces"],"limitations":["Electron-based desktop limits deployment to single-machine scenarios; no web-based multi-user access","IPC bridge adds ~50-100ms latency per operation compared to direct API calls","Desktop application must be running for runtime to be accessible; no headless-only deployment option","Workspace visualization is limited to desktop panes; no mobile or remote access"],"requires":["Electron 20+ for desktop application runtime","Node.js 18+ for runtime API server","Local HTTP server capability (port 5160 or configurable)","macOS, Windows, or Linux for desktop application deployment"],"input_types":["user interactions in desktop UI (workspace creation, model selection, run execution)","workspace configuration parameters","agent execution requests"],"output_types":["workspace visualization and state display","agent execution progress updates","model configuration and credential management UI"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-holaboss-ai--holaos__cap_6","uri":"capability://automation.workflow.app.runtime.yaml.manifest.driven.application.configuration.and.deployment","name":"app.runtime.yaml manifest-driven application configuration and deployment","description":"Uses declarative YAML manifests (app.runtime.yaml) to define agent application structure, including tool definitions, workspace configuration, memory surfaces, and execution parameters. The manifest system enables developers to specify agent capabilities and behavior through configuration rather than code, with the runtime parsing and validating manifests at startup. Manifests are versioned and can be updated without redeploying the entire application.","intents":["I need to define agent capabilities and tools through configuration rather than code","I want to version and update agent configurations without code changes","I need to validate agent configuration before deployment","I want to share agent configurations across teams or projects"],"best_for":["teams using configuration-driven agent development practices","developers building reusable agent templates and configurations","organizations needing version control and audit trails for agent configurations"],"limitations":["YAML schema validation is basic; complex conditional logic cannot be expressed in manifests","Manifest changes require runtime restart to take effect; no hot-reload capability","No built-in manifest composition or inheritance; large manifests become unwieldy","Manifest format is holaOS-specific; no standard interchange format for agent configurations"],"requires":["app.runtime.yaml file in application root or specified path","YAML parser and validator in runtime startup sequence","Schema definition for manifest validation","Version control system for manifest versioning"],"input_types":["YAML manifest file","tool schema definitions","workspace configuration parameters"],"output_types":["parsed and validated application configuration","tool registry derived from manifest","workspace definitions and memory surface specifications"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-holaboss-ai--holaos__cap_7","uri":"capability://tool.use.integration.bridge.sdk.and.app.sdk.for.agent.application.development","name":"bridge sdk and app sdk for agent application development","description":"Provides two complementary SDKs for building agent applications: Bridge SDK (@holaboss/bridge) for runtime integration and tool registration, and App SDK (@holaboss/app-sdk) for workspace and memory surface access. Both SDKs are TypeScript-first and provide type-safe abstractions over runtime APIs, enabling developers to build agent applications without direct HTTP coupling to the runtime.","intents":["I need type-safe abstractions for integrating with the holaOS runtime","I want to register tools and capabilities programmatically from TypeScript","I need to access workspace context and memory surfaces from agent code","I want to build agent applications with IDE support and compile-time type checking"],"best_for":["TypeScript developers building agent applications on holaOS","teams implementing custom agent harnesses or tool servers","developers needing type-safe runtime integration without HTTP boilerplate"],"limitations":["SDKs are TypeScript-only; no Python, Go, or other language support","Bridge SDK abstractions add ~20-50ms latency per operation compared to direct HTTP calls","App SDK memory surface access is synchronous; no async memory operations","SDK version compatibility is tightly coupled to runtime version; mismatches cause runtime errors"],"requires":["TypeScript 4.5+ for SDK usage","Node.js 18+ for runtime","@holaboss/bridge package installed via npm","@holaboss/app-sdk package installed via npm"],"input_types":["TypeScript source code","tool definitions and schemas","workspace configuration objects"],"output_types":["compiled JavaScript agent application","tool registration with runtime","workspace context and memory access"],"categories":["tool-use-integration","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-holaboss-ai--holaos__cap_8","uri":"capability://planning.reasoning.self.evolving.agent.patterns.through.workspace.modification","name":"self-evolving agent patterns through workspace modification","description":"Enables agents to modify their own workspace configuration, tool registry, and memory surfaces during execution, supporting self-evolution patterns where agents can adapt their capabilities based on learned patterns or environmental changes. Agents can update app.runtime.yaml manifests, register new tools, or modify memory surfaces through runtime APIs, with changes persisted to the state store and reflected in subsequent runs.","intents":["I need agents that can learn and adapt their own capabilities over time","I want agents to register new tools dynamically based on discovered needs","I need agents to modify their own execution patterns based on past performance","I want to enable agents to evolve without manual intervention"],"best_for":["teams building agents with adaptive, learning-based behavior","researchers exploring self-modifying agent systems","organizations implementing agents that improve through autonomous experimentation"],"limitations":["Self-modification can introduce instability if agents modify critical workspace configuration","No built-in rollback or version control for agent-initiated modifications","Self-evolution is not guaranteed to improve agent performance; no optimization guarantees","Workspace modification requires careful access control to prevent malicious self-modification"],"requires":["Runtime API endpoints for workspace modification","State store with write access for agent-initiated updates","Agent harness implementation supporting self-modification operations","Careful access control and validation of agent-initiated changes"],"input_types":["agent execution context and learned patterns","workspace modification requests from agent","new tool definitions or capability specifications"],"output_types":["updated workspace configuration","new tool registrations","modified memory surfaces and execution patterns"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-holaboss-ai--holaos__cap_9","uri":"capability://automation.workflow.proactive.agent.scheduling.and.background.execution","name":"proactive agent scheduling and background execution","description":"Supports proactive agent execution through background scheduling mechanisms that enable agents to run autonomously on defined schedules or event triggers, rather than only responding to explicit user requests. The runtime manages agent lifecycle and scheduling, enabling long-running agents that can perform continuous monitoring, learning, or maintenance tasks without user interaction.","intents":["I need agents to run autonomously on schedules without user intervention","I want agents to monitor systems or data sources continuously in the background","I need agents to perform periodic learning or optimization tasks","I want to trigger agent execution based on external events or conditions"],"best_for":["teams building autonomous agents that perform continuous background work","organizations implementing agents for monitoring, maintenance, or learning tasks","developers building agents that respond to external events or time-based triggers"],"limitations":["Scheduling is local to single holaOS instance; no distributed scheduling across multiple machines","No built-in rate limiting or resource management for background agents","Proactive execution can consume significant CPU/memory if not carefully configured","No built-in alerting or notification system for background agent failures"],"requires":["Runtime scheduler implementation (likely cron-based or event-driven)","Workspace configuration defining schedules or event triggers","Agent harness supporting background execution mode","State store for persisting schedule definitions and execution history"],"input_types":["schedule definitions (cron expressions or event specifications)","trigger conditions or event patterns","background execution parameters"],"output_types":["scheduled execution results","background agent execution logs","trigger event notifications"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":45,"verified":false,"data_access_risk":"high","permissions":["Node.js 18+ for runtime and desktop application","TypeScript for app development (Bridge SDK and App SDK)","Local HTTP server capability (runtime API server on port 5160)","SQLite support for state persistence","MCP server implementation (can be any language with MCP SDK)","app.runtime.yaml manifest defining tool schemas and server configuration","Bridge SDK (@holaboss/bridge) for tool registration in TypeScript apps","Runtime API server running to host MCP server processes","Agent Harness interface implementation","MCP tool compatibility for selected harness"],"failure_modes":["Requires local runtime deployment — no cloud-native multi-tenant isolation built-in","State store is SQLite-based, limiting horizontal scaling across multiple machines","Agent harness swapping requires compatible MCP interface implementations","Environment engineering paradigm has steeper learning curve than traditional prompt-based agents","MCP server lifecycle management is runtime-specific — no cross-runtime tool sharing","Tool schema validation relies on MCP spec compliance; malformed schemas cause runtime errors","No built-in tool versioning or backward compatibility management","Tool invocation latency includes MCP serialization/deserialization overhead","Harness interface is runtime-specific; no standard harness interface across frameworks","Harness swapping requires compatible MCP tool interface; incompatible tools cause failures","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.5515463987985479,"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:56:59.048Z","last_commit":"2026-05-03T09:57:12Z"},"community":{"stars":3985,"forks":257,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=holaboss-ai--holaos","compare_url":"https://unfragile.ai/compare?artifact=holaboss-ai--holaos"}},"signature":"YKWRFASjV0LfiT1r4VudBCI2vD9YX38tv/bsMoyVg/FoYgXOOu3+tdjZYCzS5JOxUYCLrEvu7hJ9JOqRGv0QDg==","signedAt":"2026-06-21T15:56:02.531Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/holaboss-ai--holaos","artifact":"https://unfragile.ai/holaboss-ai--holaos","verify":"https://unfragile.ai/api/v1/verify?slug=holaboss-ai--holaos","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"}}