{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-daytonaio--daytona","slug":"daytonaio--daytona","name":"daytona","type":"agent","url":"https://daytona.io","page_url":"https://unfragile.ai/daytonaio--daytona","categories":["automation"],"tags":["agentic-workflow","ai","ai-agents","ai-runtime","ai-sandboxes","code-execution","code-interpreter","developer-tools"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-daytonaio--daytona__cap_0","uri":"capability://automation.workflow.isolated.sandbox.provisioning.with.warm.pool.acceleration","name":"isolated sandbox provisioning with warm pool acceleration","description":"Daytona provisions ephemeral, containerized execution environments using a Docker-based runner system with a warm pool of pre-initialized sandboxes for sub-second startup. The system uses a runner adapter pattern to abstract container orchestration, enabling multi-region deployment with health monitoring and automatic runner selection based on resource availability and latency. Sandboxes are created from snapshots (pre-built images) or from scratch, with configurable CPU, memory, and storage allocations managed through a state reconciliation engine.","intents":["I need to spin up isolated execution environments for AI agents without managing Kubernetes or Docker infrastructure","I want sub-second sandbox startup times for interactive agent workflows","I need to run untrusted AI-generated code safely without affecting my host system"],"best_for":["AI agent builders running code-generation workflows","Teams building multi-tenant SaaS platforms with code execution","Developers prototyping AI-powered IDEs or code interpreters"],"limitations":["Warm pool requires pre-allocation of resources; cold starts without pre-warming add 2-5 second latency","Multi-region snapshot propagation introduces eventual consistency — newly created snapshots may not be immediately available in all regions","Runner health monitoring uses periodic polling rather than event-driven detection, adding up to 30 second detection lag for failed runners"],"requires":["Docker runtime on runner nodes","API key or JWT token for authentication","Network connectivity to Daytona control plane","Minimum 512MB RAM per sandbox (configurable)"],"input_types":["sandbox configuration (CPU, memory, storage, environment variables)","snapshot ID or base image reference","region preference"],"output_types":["sandbox object with ID, state, network endpoints","connection credentials (SSH, web terminal, API)"],"categories":["automation-workflow","infrastructure-as-code"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-daytonaio--daytona__cap_1","uri":"capability://automation.workflow.snapshot.based.image.management.with.distributed.propagation","name":"snapshot-based image management with distributed propagation","description":"Daytona implements a snapshot system that captures sandbox state (filesystem, installed packages, configuration) as immutable images that can be versioned, published, and distributed across regions. The snapshot manager handles creation, lifecycle management, and propagation using an event-driven architecture (snapshot-activated.event.ts) that triggers distribution to regional runners. Snapshots support incremental updates and can be used as base images for new sandboxes, enabling reproducible execution environments and fast sandbox cloning.","intents":["I want to create reproducible sandbox templates with pre-installed dependencies for my agents","I need to distribute custom runtime environments across multiple regions without rebuilding","I want to version and rollback sandbox configurations"],"best_for":["Teams managing multiple AI agent configurations with shared dependencies","Multi-region deployments requiring consistent runtime environments","Organizations needing audit trails of sandbox configuration changes"],"limitations":["Snapshot creation requires sandbox to be in stopped state; no live snapshots of running sandboxes","Snapshot propagation to all regions is asynchronous with no built-in rollback if propagation fails on some runners","Snapshot size is unbounded — large snapshots (>10GB) may cause slow distribution and high storage costs"],"requires":["Stopped or paused sandbox to snapshot from","Storage backend configured (local or cloud)","Sufficient disk space for snapshot storage"],"input_types":["sandbox ID to snapshot","snapshot metadata (name, description, tags)","target regions for propagation"],"output_types":["snapshot object with ID, size, creation timestamp","propagation status per region"],"categories":["automation-workflow","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-daytonaio--daytona__cap_10","uri":"capability://automation.workflow.event.driven.state.reconciliation.and.consistency","name":"event-driven state reconciliation and consistency","description":"Daytona uses an event-driven architecture (event-driven architecture section) where state changes in sandboxes, snapshots, and runners trigger events that are processed asynchronously. The system maintains eventual consistency between the control plane and runner nodes through periodic reconciliation jobs that compare desired state (in database) with actual state (on runners). Events are stored in the database and processed by event handlers that update related entities.","intents":["I want the control plane to automatically detect and recover from runner failures","I need to ensure sandbox state is consistent between the API and runner nodes","I want to trigger cascading updates when a snapshot is activated or a sandbox is destroyed"],"best_for":["Large-scale deployments with many runners where failures are expected","Systems requiring eventual consistency rather than strong consistency","Applications needing to react to state changes (e.g., send notifications)"],"limitations":["Event processing is asynchronous; state changes are not immediately visible to clients","Event handlers are not transactional; if a handler fails, the event is retried but may be processed multiple times","No built-in event replay; if events are lost, state may become inconsistent"],"requires":["Event-driven architecture enabled in configuration","Database for event storage","Event handlers registered for relevant event types"],"input_types":["event type (sandbox-created, snapshot-activated, runner-failed, etc.)","event payload (entity ID, state change, etc.)"],"output_types":["event processing status (pending, processed, failed)","side effects (updated entities, triggered actions)"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-daytonaio--daytona__cap_11","uri":"capability://data.processing.analysis.multi.database.storage.strategy.with.configuration.management","name":"multi-database storage strategy with configuration management","description":"Daytona uses a multi-database storage strategy (multi-database storage strategy section) where different data types are stored in different backends optimized for their access patterns. The configuration management system (configuration.ts, typed-config.service.ts) provides centralized configuration with environment variable overrides and type-safe access. The system supports migrations (TypeORM migrations) for schema evolution and supports multiple database backends (PostgreSQL, MySQL, etc.).","intents":["I want to scale different data types independently (e.g., time-series metrics separately from entity data)","I need to manage configuration across development, staging, and production environments","I want to evolve the database schema without downtime"],"best_for":["Large-scale deployments with high data volume","Organizations with strict data governance requirements","Teams managing multiple environments with different configurations"],"limitations":["Multi-database strategy adds operational complexity; requires managing multiple database instances","Migrations must be run manually before deploying new code; no automatic schema evolution","Configuration is loaded at startup; changes require API restart"],"requires":["Multiple database instances (one for operational data, one for time-series, etc.)","Database credentials in environment variables or configuration file","TypeORM CLI for running migrations"],"input_types":["configuration key (database URL, API port, log level, etc.)","environment variable override"],"output_types":["typed configuration object with all settings","migration status (pending, applied)"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-daytonaio--daytona__cap_12","uri":"capability://automation.workflow.runner.health.monitoring.and.adaptive.selection","name":"runner health monitoring and adaptive selection","description":"Daytona monitors runner node health through periodic health checks and tracks metrics (CPU, memory, disk usage, container count). The runner selection algorithm (runner selection and health monitoring section) uses these metrics to choose the best runner for new sandboxes, considering resource availability, latency, and region preference. Unhealthy runners are automatically marked as unavailable and excluded from selection. The system supports multiple runner versions through the runner adapter pattern.","intents":["I want sandboxes to be placed on runners with sufficient available resources","I need to detect and isolate failing runners automatically","I want to optimize for latency by selecting runners in the same region as the user"],"best_for":["Multi-region deployments with many runners","Systems requiring high availability and automatic failover","Applications sensitive to latency (interactive agents)"],"limitations":["Health checks are periodic (every 30 seconds); unhealthy runners may accept new sandboxes for up to 30 seconds before being marked unavailable","Runner selection algorithm is greedy (first-fit); no load balancing across equally healthy runners","No support for custom runner selection policies; algorithm is fixed"],"requires":["Multiple runner nodes with health check endpoints","Network connectivity between control plane and runners","Metrics collection system (optional; defaults to basic health checks)"],"input_types":["runner node configuration (address, region, capacity)","health check interval and timeout"],"output_types":["runner health status (healthy, unhealthy, unknown)","runner metrics (CPU, memory, disk, container count)","selected runner for new sandbox"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-daytonaio--daytona__cap_13","uri":"capability://safety.moderation.observability.and.telemetry.with.opentelemetry.integration","name":"observability and telemetry with opentelemetry integration","description":"Daytona integrates OpenTelemetry for distributed tracing, metrics collection, and logging. The observability system (observability and telemetry section) exports traces to compatible backends (Jaeger, Datadog, etc.) and metrics to time-series databases. Audit logging captures all user actions (create, read, update, delete) with actor, timestamp, and resource information. The system provides built-in dashboards for monitoring sandbox lifecycle, resource usage, and API performance.","intents":["I want to trace requests through the system to identify performance bottlenecks","I need metrics on sandbox creation time, resource usage, and API latency","I want audit logs for compliance and debugging"],"best_for":["Large-scale deployments requiring observability","Organizations with compliance requirements for audit logging","Teams debugging performance issues"],"limitations":["OpenTelemetry integration requires external backend (Jaeger, Datadog, etc.); no built-in storage","Audit logging is stored in the same database as operational data; no separate audit log retention","Metrics are sampled; high-volume systems may lose some data points"],"requires":["OpenTelemetry collector configured (for trace/metric export)","Compatible backend (Jaeger, Datadog, Prometheus, etc.)","Sufficient storage for audit logs"],"input_types":["OpenTelemetry exporter configuration (endpoint, API key, etc.)","audit log retention policy"],"output_types":["distributed traces (request flow through system)","metrics (latency, throughput, resource usage)","audit log entries (actor, action, resource, timestamp)"],"categories":["safety-moderation","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-daytonaio--daytona__cap_2","uri":"capability://safety.moderation.multi.tenant.organization.and.role.based.access.control","name":"multi-tenant organization and role-based access control","description":"Daytona provides organization-level isolation with role-based access control (RBAC) and resource quotas enforced at the API layer. Organizations can have multiple members with granular permissions (create, read, update, delete sandboxes; manage snapshots; configure organization settings). The system supports organization suspension, member invitations, and audit logging of all actions. Authentication uses API keys with scoped permissions and JWT tokens for session-based access, managed through combined-auth.guard.ts.","intents":["I need to isolate resources and access between different teams or customers","I want to enforce resource quotas per organization to prevent runaway costs","I need audit trails of who created/modified/deleted sandboxes for compliance"],"best_for":["SaaS platforms offering Daytona as a managed service","Enterprise teams with multiple departments needing resource isolation","Compliance-heavy organizations requiring audit logging"],"limitations":["RBAC is coarse-grained (organization-level); no fine-grained per-sandbox permissions","Resource quotas are enforced at organization level but not at individual user level","Audit logging is stored in the same database as operational data; no separate audit log retention policy"],"requires":["Organization created and user invited to organization","API key with appropriate scopes or valid JWT token","Organization must not be in suspended state"],"input_types":["organization name and metadata","member email and role (admin, developer, viewer)","resource quota limits (max sandboxes, max storage)"],"output_types":["organization object with ID, members list, quotas","audit log entries with timestamp, actor, action, resource"],"categories":["safety-moderation","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-daytonaio--daytona__cap_3","uri":"capability://automation.workflow.sandbox.lifecycle.management.with.auto.cleanup.policies","name":"sandbox lifecycle management with auto-cleanup policies","description":"Daytona manages sandbox state transitions (created, running, stopped, archived, destroyed) through a state machine implemented in sandbox.manager.ts with action handlers (sandbox-start.action.ts, sandbox-stop.action.ts, sandbox-archive.action.ts, sandbox-destroy.action.ts). Auto-management policies can automatically stop idle sandboxes after a configurable duration or destroy sandboxes after expiration. The system uses event-driven state reconciliation to ensure consistency between the control plane and runner nodes, with background jobs (cron system) periodically checking for policy violations.","intents":["I want sandboxes to automatically stop after inactivity to reduce costs","I need to enforce sandbox lifetime limits to prevent resource leaks","I want to archive sandboxes for compliance before permanent deletion"],"best_for":["Cost-conscious teams running many short-lived sandboxes","Platforms with strict resource governance requirements","Organizations needing compliance-friendly sandbox retention"],"limitations":["Auto-cleanup policies are evaluated by background cron jobs running every 5-10 minutes; cleanup is not immediate upon policy violation","State reconciliation is eventual consistent — if a runner crashes, the control plane may not detect the sandbox failure for up to 30 seconds","Archive operation requires sufficient storage; no automatic cleanup of old archives"],"requires":["Sandbox in valid state (running, stopped, etc.)","Auto-management policy configured (optional; defaults to no auto-cleanup)","Background job system running on control plane"],"input_types":["sandbox ID","target state (running, stopped, archived, destroyed)","auto-management policy (idle timeout, max lifetime)"],"output_types":["updated sandbox object with new state","state transition timestamp"],"categories":["automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-daytonaio--daytona__cap_4","uri":"capability://automation.workflow.persistent.volume.and.storage.management","name":"persistent volume and storage management","description":"Daytona provides persistent storage volumes that can be attached to sandboxes, surviving sandbox stop/start cycles but destroyed when the sandbox is deleted. Volumes support configurable size, mount paths, and can be backed up through the backup manager. The system tracks volume usage and enforces storage quotas at the organization level. Volumes are implemented as Docker volumes on runner nodes with optional cloud storage backends for durability.","intents":["I need to persist data generated by AI agents across sandbox restarts","I want to backup sandbox data for disaster recovery","I need to enforce storage quotas to prevent runaway disk usage"],"best_for":["Agents that generate large artifacts (datasets, models, logs)","Applications requiring data persistence across sandbox lifecycle","Teams with strict data retention and backup requirements"],"limitations":["Volumes are local to a runner node; moving a sandbox to a different region requires manual volume migration","No built-in volume replication or redundancy; volume loss if runner node fails","Backup operation is synchronous and blocks sandbox operations during backup"],"requires":["Sandbox created with volume configuration","Sufficient storage quota remaining in organization","Runner node with available disk space"],"input_types":["volume size (GB)","mount path in sandbox","backup frequency (optional)"],"output_types":["volume object with ID, size, mount path, usage","backup object with timestamp, size, status"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-daytonaio--daytona__cap_5","uri":"capability://automation.workflow.network.configuration.and.preview.url.proxy","name":"network configuration and preview url proxy","description":"Daytona provides network isolation for sandboxes with configurable inbound/outbound rules enforced at the runner level. The proxy system (proxy architecture and request flow) intercepts HTTP requests to preview URLs and routes them to sandbox services, with built-in caching strategy and authentication flow. Preview URLs are publicly accessible but can be protected with authentication tokens. The system supports custom preview proxy deployment for on-premises installations.","intents":["I want to expose web services running in sandboxes without opening SSH ports","I need to share sandbox outputs (web UIs, dashboards) with non-technical stakeholders","I want to control network access to sandboxes (allow/deny specific ports or IPs)"],"best_for":["Teams building web-based AI agents or code interpreters","Applications requiring secure sharing of sandbox outputs","Organizations with strict network security policies"],"limitations":["Preview URLs are globally accessible (though can be protected with auth tokens); no IP-based access control","Proxy caching strategy is simple (HTTP cache headers only); no smart cache invalidation for dynamic content","Custom preview proxy deployment requires manual setup and maintenance"],"requires":["Sandbox running a web service on a specific port","Network rule allowing outbound traffic on that port","Preview URL authentication token (optional)"],"input_types":["sandbox ID","internal port number","authentication requirement (public, token-protected, IP-restricted)"],"output_types":["preview URL (https://sandbox-id.daytona.io:port)","authentication token (if required)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-daytonaio--daytona__cap_6","uri":"capability://tool.use.integration.multi.sdk.support.with.unified.api.abstraction","name":"multi-sdk support with unified api abstraction","description":"Daytona provides SDKs for Python, TypeScript, and Go that abstract the REST API into language-native interfaces. The SDK architecture (SDK architecture section) uses a common error handling and timeout strategy across all SDKs, with automatic retry logic and exponential backoff. SDKs support both synchronous and asynchronous operations, with streaming support for long-running tasks. Generated API clients are available for additional languages via OpenAPI specification.","intents":["I want to integrate Daytona into my Python/TypeScript/Go application without writing HTTP clients","I need async/await support for non-blocking sandbox operations","I want automatic retry logic and timeout handling for reliability"],"best_for":["Developers building AI agents in Python, TypeScript, or Go","Teams integrating Daytona into existing applications","Projects requiring language-native error handling and type safety"],"limitations":["SDKs are generated from OpenAPI spec; custom logic is limited to what the spec exposes","Async support varies by SDK (TypeScript has full async/await; Python has asyncio; Go uses goroutines)","Streaming support is limited to specific endpoints (logs, terminal output)"],"requires":["Python 3.8+ (Python SDK) or Node.js 16+ (TypeScript SDK) or Go 1.18+ (Go SDK)","API key or JWT token for authentication","Network connectivity to Daytona API"],"input_types":["API credentials (API key or JWT)","configuration (base URL, timeout, retry policy)"],"output_types":["SDK client object with methods for sandbox operations","typed response objects (Sandbox, Snapshot, etc.)"],"categories":["tool-use-integration","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-daytonaio--daytona__cap_7","uri":"capability://automation.workflow.web.terminal.and.ssh.access.with.authentication","name":"web terminal and ssh access with authentication","description":"Daytona provides multiple access methods to sandboxes: web-based terminal accessible through the dashboard, SSH access with key-based authentication, and programmatic access via SDKs. The proxy authentication flow (proxy-auth.flow) handles session management for web terminal access. SSH access uses standard OpenSSH with Daytona-managed keys. All access is logged for audit purposes and can be restricted by organization-level policies.","intents":["I want to interactively debug code running in a sandbox without SSH setup","I need SSH access for integration with existing tools (git, rsync, etc.)","I want audit logs of who accessed which sandboxes and when"],"best_for":["Developers debugging AI agent execution","Teams integrating Daytona with CI/CD pipelines","Organizations with compliance requirements for access logging"],"limitations":["Web terminal is limited to basic shell operations; no file upload/download through web UI","SSH key management is handled by Daytona; users cannot bring their own keys","Web terminal sessions are not persistent across browser refreshes"],"requires":["Sandbox in running state","Valid API key or JWT token for web terminal","SSH client installed (for SSH access)"],"input_types":["sandbox ID","authentication credentials (API key or SSH key)"],"output_types":["web terminal session (WebSocket connection)","SSH connection details (host, port, username)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-daytonaio--daytona__cap_8","uri":"capability://tool.use.integration.rest.api.with.openapi.specification.and.generated.clients","name":"rest api with openapi specification and generated clients","description":"Daytona exposes a comprehensive REST API documented via OpenAPI specification, with auto-generated API clients for multiple languages. The API service architecture (API service architecture section) uses NestJS with controller-based routing (sandbox.controller.ts, job.controller.ts) and dependency injection for modularity. API endpoints support standard HTTP methods (GET, POST, PUT, DELETE) with JSON request/response bodies. The API is versioned and supports pagination, filtering, and sorting on list endpoints.","intents":["I want to automate sandbox management through HTTP requests","I need to integrate Daytona with third-party tools via REST API","I want to generate API clients for languages not officially supported"],"best_for":["Teams building custom integrations with Daytona","Organizations using API-first architecture","Projects requiring language-agnostic API access"],"limitations":["API is synchronous only; long-running operations return immediately with a job ID (no webhooks for completion)","Pagination is limited to offset/limit; no cursor-based pagination for large result sets","API rate limiting is per-organization; no per-user rate limits"],"requires":["API key or JWT token for authentication","Network connectivity to Daytona API endpoint","HTTP client library"],"input_types":["HTTP method (GET, POST, PUT, DELETE)","endpoint path","JSON request body (for POST/PUT)","query parameters (for filtering, pagination)"],"output_types":["JSON response body with resource data","HTTP status code (200, 201, 400, 401, 404, 500, etc.)","job ID for async operations"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-daytonaio--daytona__cap_9","uri":"capability://automation.workflow.background.job.system.with.cron.based.scheduling","name":"background job system with cron-based scheduling","description":"Daytona implements a background job system (background jobs and cron system section) that executes scheduled tasks on the control plane, such as evaluating auto-management policies, propagating snapshots to regions, and reconciling sandbox state. Jobs are stored in the database and executed by a scheduler that runs on the API service. The system supports cron expressions for periodic jobs and one-time jobs with retry logic and exponential backoff.","intents":["I want to automatically clean up idle sandboxes without manual intervention","I need to distribute snapshots to multiple regions asynchronously","I want to reconcile sandbox state between control plane and runners periodically"],"best_for":["Large-scale deployments with many sandboxes requiring periodic maintenance","Multi-region setups needing asynchronous snapshot propagation","Organizations requiring eventual consistency between control plane and runners"],"limitations":["Job scheduler runs on a single API instance; no distributed scheduling across multiple instances","Job execution is not guaranteed if the API instance crashes; jobs may be lost if not persisted","Cron expressions are evaluated in UTC; no timezone support"],"requires":["Background job system enabled in configuration","Database connectivity for job persistence","At least one API instance running the scheduler"],"input_types":["job type (auto-cleanup, snapshot-propagation, state-reconciliation, etc.)","cron expression (for periodic jobs)","job parameters (sandbox ID, policy, etc.)"],"output_types":["job execution status (pending, running, completed, failed)","job result (number of sandboxes cleaned up, etc.)"],"categories":["automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":52,"verified":false,"data_access_risk":"high","permissions":["Docker runtime on runner nodes","API key or JWT token for authentication","Network connectivity to Daytona control plane","Minimum 512MB RAM per sandbox (configurable)","Stopped or paused sandbox to snapshot from","Storage backend configured (local or cloud)","Sufficient disk space for snapshot storage","Event-driven architecture enabled in configuration","Database for event storage","Event handlers registered for relevant event types"],"failure_modes":["Warm pool requires pre-allocation of resources; cold starts without pre-warming add 2-5 second latency","Multi-region snapshot propagation introduces eventual consistency — newly created snapshots may not be immediately available in all regions","Runner health monitoring uses periodic polling rather than event-driven detection, adding up to 30 second detection lag for failed runners","Snapshot creation requires sandbox to be in stopped state; no live snapshots of running sandboxes","Snapshot propagation to all regions is asynchronous with no built-in rollback if propagation fails on some runners","Snapshot size is unbounded — large snapshots (>10GB) may cause slow distribution and high storage costs","Event processing is asynchronous; state changes are not immediately visible to clients","Event handlers are not transactional; if a handler fails, the event is retried but may be processed multiple times","No built-in event replay; if events are lost, state may become inconsistent","Multi-database strategy adds operational complexity; requires managing multiple database instances","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.8564980646243104,"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.549Z","last_scraped_at":"2026-05-03T13:57:06.483Z","last_commit":"2026-05-03T11:30:14Z"},"community":{"stars":72378,"forks":5540,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=daytonaio--daytona","compare_url":"https://unfragile.ai/compare?artifact=daytonaio--daytona"}},"signature":"5JWhbpR02uJlV7Xb9zHtDcOp+Ylzuk6arFDc2cCIy7Qn7KI3gPfP028iKu/JSCh2ncQx/k9wvPTJ/wngu08QDg==","signedAt":"2026-06-20T07:09:17.512Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/daytonaio--daytona","artifact":"https://unfragile.ai/daytonaio--daytona","verify":"https://unfragile.ai/api/v1/verify?slug=daytonaio--daytona","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"}}