{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"awesome-input","slug":"input","name":"Input","type":"product","url":"https://useinput.com/","page_url":"https://unfragile.ai/input","categories":["app-builders"],"tags":[],"pricing":{"model":"unknown","free":false,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"awesome-input__cap_0","uri":"capability://code.generation.editing.real.time.collaborative.code.editing.with.ai.suggestions","name":"real-time collaborative code editing with ai suggestions","description":"Enables multiple developers to edit code simultaneously in a shared workspace while an AI agent observes context and provides inline code suggestions, completions, and refactoring recommendations. The system maintains operational transformation or CRDT-based conflict resolution to synchronize edits across clients, with the AI model receiving full AST context of the current file and surrounding codebase to generate contextually-aware suggestions without requiring explicit prompts.","intents":["I want my AI teammate to suggest the next line of code as I'm typing, understanding the full context of my project","I need real-time code review feedback from an AI while collaborating with human teammates","I want to pair program with an AI agent that sees exactly what I'm seeing and can jump in with suggestions"],"best_for":["Small to medium teams (2-10 developers) building web applications or services","Solo developers who want an AI pair programmer integrated into their IDE workflow","Teams using VS Code or web-based editors who want minimal setup friction"],"limitations":["Real-time collaboration latency depends on network conditions; high-latency connections may cause suggestion delays >500ms","AI suggestions are context-aware only within the current file and immediate imports; cross-service understanding requires explicit codebase indexing","Concurrent edits from multiple users may cause suggestion staleness if the AI model processes stale AST snapshots"],"requires":["VS Code 1.70+ or compatible web editor","Active internet connection for AI model inference","Project codebase accessible to the AI agent (local or cloud-based)"],"input_types":["source code (JavaScript, TypeScript, Python, Go, Rust, etc.)","file context (imports, dependencies, project structure)","user editing actions (keystrokes, selections, cursor position)"],"output_types":["inline code suggestions","multi-line code completions","refactoring recommendations with diffs"],"categories":["code-generation-editing","collaboration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-input__cap_1","uri":"capability://memory.knowledge.codebase.aware.context.indexing.and.retrieval","name":"codebase-aware context indexing and retrieval","description":"Automatically indexes the entire project codebase (source files, dependencies, documentation) into a searchable knowledge graph or vector database, enabling the AI agent to retrieve relevant code patterns, function signatures, and architectural context when generating suggestions. Uses semantic search or AST-based matching to find similar code patterns across the codebase and surface them as context for the AI model, reducing hallucinations and improving consistency with existing code style.","intents":["I want the AI to understand my project's architecture and coding patterns so suggestions match my style","I need the AI to find and reuse existing utility functions instead of generating duplicate code","I want the AI to be aware of my project's dependencies and use them correctly in suggestions"],"best_for":["Teams with large or complex codebases (>10k lines) where consistency and pattern reuse are critical","Projects with custom libraries or domain-specific code patterns that generic AI models wouldn't know","Organizations that want to enforce architectural constraints and coding standards via AI suggestions"],"limitations":["Initial indexing of large codebases (>100k lines) may take 5-15 minutes; incremental updates are faster but still add latency","Vector-based retrieval may miss relevant code if semantic similarity is low; requires tuning of embedding model and similarity thresholds","Indexing requires read access to all source files; private or encrypted code may not be indexed correctly"],"requires":["Codebase accessible to Input (local or cloud-synced)","Supported language parsers for AST extraction (JavaScript, TypeScript, Python, Go, Rust, Java, C#)","Sufficient disk space for index storage (typically 10-20% of source code size)"],"input_types":["source code files","dependency manifests (package.json, requirements.txt, go.mod, etc.)","documentation files (README, comments, docstrings)"],"output_types":["ranked list of similar code patterns","relevant function signatures and imports","architectural context and design patterns"],"categories":["memory-knowledge","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-input__cap_10","uri":"capability://search.retrieval.intelligent.code.navigation.and.symbol.search","name":"intelligent code navigation and symbol search","description":"Provides semantic code navigation that goes beyond simple text search by understanding code structure, type definitions, and dependencies. Enables jumping to definitions, finding all usages, and discovering related code through semantic relationships. Uses AST-based symbol resolution and type inference to handle complex cases like polymorphism, generics, and dynamic imports.","intents":["I want to jump to the definition of a function or class, even if it's in a different file or module","I need to find all usages of a symbol across the codebase","I want to discover related code (implementations, tests, documentation) for a given symbol"],"best_for":["Developers working with large, complex codebases where manual navigation is time-consuming","Teams with multiple modules or microservices that need cross-service code navigation","Projects with heavy use of inheritance, generics, or dynamic code patterns"],"limitations":["Symbol resolution accuracy depends on type information; dynamically-typed code or reflection may not resolve correctly","Cross-language navigation (e.g., JavaScript calling Python APIs) requires multi-language support","Performance may degrade for very large codebases (>1M lines) without proper indexing and caching"],"requires":["Full codebase indexing with AST-based symbol extraction","Type information (from type annotations, type stubs, or type inference)","IDE integration (VS Code, JetBrains, etc.)"],"input_types":["symbol name or code location","search scope (file, directory, codebase)"],"output_types":["definition location with code snippet","list of usages with context","related code (tests, documentation, implementations)"],"categories":["search-retrieval","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-input__cap_11","uri":"capability://memory.knowledge.collaborative.knowledge.base.and.team.learning","name":"collaborative knowledge base and team learning","description":"Builds a shared knowledge base of team decisions, architectural patterns, and best practices by analyzing code, documentation, and team discussions. Makes this knowledge available to the AI agent to inform suggestions and to team members for learning. Tracks decision rationale and enables searching for similar past decisions to avoid repeating mistakes or reinventing solutions.","intents":["I want to document architectural decisions and have the AI reference them in future suggestions","I need to find similar past decisions or solutions to inform current work","I want new team members to learn from the team's accumulated knowledge and best practices"],"best_for":["Teams with strong engineering culture and emphasis on knowledge sharing","Organizations with high turnover where institutional knowledge is at risk","Projects with complex architectural decisions that need to be documented and understood"],"limitations":["Knowledge base quality depends on team participation and documentation discipline; incomplete or outdated knowledge reduces effectiveness","Extracting knowledge from code and discussions is imperfect; requires human curation and validation","Privacy and access control are important; sensitive decisions or patterns may need to be restricted"],"requires":["Team participation and willingness to document decisions","Integration with communication tools (Slack, Discord, GitHub discussions) for knowledge extraction","Codebase context for pattern extraction"],"input_types":["code and architectural patterns","documentation and decision records","team discussions and chat messages","code review comments"],"output_types":["searchable knowledge base with decision rationale","pattern recommendations based on past decisions","learning resources for new team members","decision impact analysis"],"categories":["memory-knowledge","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-input__cap_12","uri":"capability://automation.workflow.continuous.integration.and.deployment.assistance","name":"continuous integration and deployment assistance","description":"Integrates with CI/CD pipelines to provide AI-assisted deployment decisions, rollback recommendations, and incident response. Analyzes test results, deployment logs, and production metrics to identify issues early and suggest remediation. Automates routine deployment tasks (version bumping, changelog generation, release notes) and provides deployment safety checks.","intents":["I want the AI to analyze test failures and suggest fixes before deployment","I need help deciding whether a deployment is safe or should be rolled back","I want to automate routine deployment tasks like version bumping and changelog generation"],"best_for":["Teams with frequent deployments (daily or more) where automation provides significant value","Projects with complex deployment pipelines or multiple environments","Organizations with high availability requirements where deployment safety is critical"],"limitations":["AI-assisted deployment decisions require accurate production metrics and monitoring; incomplete data leads to poor recommendations","Rollback recommendations are heuristic-based; some issues may require manual investigation and decision-making","Automation of deployment tasks requires careful configuration to avoid unintended consequences (e.g., incorrect version bumping)"],"requires":["CI/CD pipeline integration (GitHub Actions, GitLab CI, Jenkins, etc.)","Access to test results and deployment logs","Production monitoring and metrics (optional but recommended)","Version control integration (git) for changelog and release notes generation"],"input_types":["test results and logs","deployment logs and metrics","production monitoring data","git commit history"],"output_types":["deployment safety assessment","rollback recommendations with reasoning","automated version bumping and changelog generation","incident response suggestions"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-input__cap_2","uri":"capability://code.generation.editing.ai.driven.code.review.and.refactoring.suggestions","name":"ai-driven code review and refactoring suggestions","description":"Analyzes code changes (diffs, pull requests, or file edits) and generates targeted refactoring suggestions, bug detection, and style improvements based on the codebase's established patterns and best practices. The AI agent uses static analysis (AST traversal, control flow analysis) combined with semantic understanding to identify anti-patterns, suggest performance optimizations, and flag potential bugs before code review.","intents":["I want automated code review feedback that catches bugs and style issues before human review","I need suggestions for refactoring complex functions into smaller, more testable pieces","I want the AI to flag performance issues or security vulnerabilities in my code changes"],"best_for":["Teams with formal code review processes who want to automate initial triage and feedback","Projects where code quality and consistency are critical (financial services, healthcare, security-sensitive applications)","Solo developers who want a second opinion on code quality before committing"],"limitations":["AI-generated refactoring suggestions may not account for business logic or domain-specific constraints; requires human validation","False positives are common for complex control flow or dynamic code patterns; requires tuning of detection rules","Performance analysis is limited to static patterns; runtime profiling or load testing is still required for production optimization"],"requires":["Access to code diffs or file changes","Codebase context (via indexing capability)","Language-specific AST parsers for structural analysis"],"input_types":["code diffs (unified diff format)","pull request metadata (title, description, changed files)","source code files for context"],"output_types":["refactoring suggestions with before/after code","bug and vulnerability warnings with severity levels","style and consistency feedback with explanations"],"categories":["code-generation-editing","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-input__cap_3","uri":"capability://planning.reasoning.multi.developer.task.decomposition.and.assignment","name":"multi-developer task decomposition and assignment","description":"Breaks down high-level feature requests or bug reports into discrete, assignable tasks with estimated effort and dependencies, then recommends which team member should own each task based on their expertise and current workload. Uses natural language understanding to parse requirements, generates task descriptions with acceptance criteria, and maintains a dependency graph to identify blocking tasks and optimal execution order.","intents":["I want to describe a feature and have the AI break it down into tasks for my team","I need to estimate effort and identify dependencies for a complex feature request","I want the AI to recommend who on my team should work on each task based on their skills"],"best_for":["Small to medium teams (3-15 developers) with diverse skill sets and specializations","Projects with frequent feature requests or bug reports that need rapid triage and assignment","Teams using agile or kanban workflows who want to automate sprint planning"],"limitations":["Task decomposition requires understanding of project architecture and team capabilities; accuracy depends on quality of codebase context and team metadata","Effort estimation is heuristic-based and may be inaccurate for novel or complex features; requires human review and adjustment","Skill-based task assignment requires explicit team member profiles (skills, experience, current workload); without this data, recommendations are generic"],"requires":["Team member profiles with skills and expertise areas","Current task/sprint data (workload, active assignments)","Codebase context for understanding architecture and complexity","Integration with project management tool (Jira, Linear, GitHub Projects, etc.)"],"input_types":["natural language feature descriptions or bug reports","team member profiles and skill tags","current sprint or backlog data"],"output_types":["structured task list with descriptions and acceptance criteria","effort estimates (story points or time ranges)","task dependency graph","recommended task assignments with reasoning"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-input__cap_4","uri":"capability://text.generation.language.intelligent.documentation.generation.and.synchronization","name":"intelligent documentation generation and synchronization","description":"Automatically generates and maintains API documentation, architecture diagrams, and code comments by analyzing the codebase structure, function signatures, and type definitions. Detects when documentation is out-of-sync with code changes and suggests updates, ensuring documentation stays current without manual effort. Uses AST analysis to extract function signatures, parameter types, and return types, then generates human-readable descriptions and examples.","intents":["I want to auto-generate API documentation from my code without writing it manually","I need to keep documentation in sync with code changes automatically","I want the AI to generate architecture diagrams and design documentation from the codebase"],"best_for":["Teams with large APIs or libraries where documentation maintenance is a burden","Projects with frequent code changes where documentation quickly becomes stale","Open-source projects that need high-quality documentation to attract contributors"],"limitations":["Generated documentation may lack business context or domain-specific explanations; requires human review and enrichment","Diagram generation is limited to structural relationships; complex interactions or state machines require manual refinement","Documentation quality depends on code quality (clear naming, type annotations, docstrings); poorly-written code generates poor documentation"],"requires":["Type annotations or JSDoc comments in source code (for better documentation quality)","Supported language parsers for AST extraction","Documentation template or format preference (Markdown, HTML, OpenAPI, etc.)"],"input_types":["source code files with function signatures and type definitions","existing documentation (for sync detection)","code comments and docstrings"],"output_types":["API documentation (Markdown, HTML, or OpenAPI format)","architecture diagrams (Mermaid, PlantUML, or SVG)","code comments and docstrings","change notifications when documentation is out-of-sync"],"categories":["text-generation-language","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-input__cap_5","uri":"capability://code.generation.editing.collaborative.debugging.with.ai.assisted.root.cause.analysis","name":"collaborative debugging with ai-assisted root cause analysis","description":"Provides real-time debugging assistance by analyzing stack traces, logs, and error messages to suggest root causes and potential fixes. The AI agent can inspect variable state, trace execution paths, and correlate errors with recent code changes to narrow down the source of bugs. Integrates with debugger APIs to inspect runtime state and provide context-aware debugging suggestions without requiring manual breakpoint setup.","intents":["I have a stack trace and want the AI to help me understand what went wrong","I want the AI to correlate recent code changes with a bug to identify the likely culprit","I need help tracing through complex execution paths to find where a bug is occurring"],"best_for":["Teams debugging complex, multi-service applications where root cause analysis is time-consuming","Solo developers who want AI assistance to speed up debugging workflows","Projects with high error rates or production incidents that need rapid triage"],"limitations":["Root cause analysis requires access to logs, stack traces, and code context; incomplete information leads to inaccurate suggestions","Debugger integration is language and runtime-specific; not all languages/runtimes are supported equally","AI suggestions are heuristic-based and may miss subtle bugs or race conditions that require deep domain knowledge"],"requires":["Access to error logs and stack traces","Codebase context for understanding code flow","Debugger API integration (VS Code Debugger, Chrome DevTools, etc.)","Recent code change history (git log) for correlation analysis"],"input_types":["stack traces and error messages","application logs","variable state and memory dumps","code diffs from recent changes"],"output_types":["root cause analysis with confidence levels","suggested fixes with code examples","debugging steps and breakpoint recommendations","related code sections and dependencies"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-input__cap_6","uri":"capability://code.generation.editing.test.generation.and.coverage.optimization","name":"test generation and coverage optimization","description":"Automatically generates unit tests, integration tests, and end-to-end tests based on code structure, function signatures, and existing test patterns in the codebase. Analyzes code coverage and identifies untested code paths, then generates targeted tests to improve coverage. Uses mutation testing concepts to generate edge case tests that catch subtle bugs, and learns from existing tests to match the project's testing style and conventions.","intents":["I want the AI to generate unit tests for my functions automatically","I need to improve code coverage and want the AI to identify and test untested code paths","I want the AI to generate edge case tests that catch subtle bugs"],"best_for":["Teams with low test coverage who want to improve quality without manual test writing","Projects with complex business logic where edge case testing is critical","Teams adopting test-driven development who want AI assistance to accelerate test writing"],"limitations":["Generated tests may not cover all business logic or domain-specific edge cases; requires human review and enrichment","Test generation quality depends on code clarity and existing test examples; poorly-written code generates poor tests","Mutation testing is computationally expensive; full coverage analysis may take minutes to hours for large codebases"],"requires":["Codebase context and existing test examples (for style matching)","Test framework and assertion library (Jest, Pytest, Mocha, etc.)","Language-specific test generation templates"],"input_types":["source code files with function signatures","existing test files (for pattern matching)","code coverage reports"],"output_types":["generated unit tests with assertions","integration test templates","edge case test suggestions","coverage improvement recommendations"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-input__cap_7","uri":"capability://code.generation.editing.cross.file.refactoring.with.dependency.tracking","name":"cross-file refactoring with dependency tracking","description":"Enables large-scale refactoring operations (renaming, moving functions, extracting modules) that span multiple files and update all dependent code automatically. Maintains a dependency graph to identify all usages of a symbol across the codebase and applies consistent changes, with preview and rollback capabilities. Uses AST-based symbol resolution to handle complex cases like aliased imports, re-exports, and dynamic requires.","intents":["I want to rename a function and have all usages updated automatically across the codebase","I need to move a module to a different location and update all imports","I want to extract a shared utility and update all code that should use it"],"best_for":["Teams with large codebases (>50k lines) where manual refactoring is error-prone","Projects with complex dependency graphs where tracking usages manually is impractical","Teams doing architectural refactoring or module reorganization"],"limitations":["Refactoring accuracy depends on AST-based symbol resolution; dynamic requires, eval, or reflection may not be tracked correctly","Cross-language refactoring (e.g., renaming a function used in both JavaScript and Python) requires multi-language support","Large refactoring operations may require significant processing time; preview generation may take minutes for very large codebases"],"requires":["Full codebase access and indexing","Language-specific AST parsers and symbol resolution","Version control integration (git) for change tracking and rollback"],"input_types":["refactoring operation (rename, move, extract)","target symbol or code range","refactoring scope (file, directory, entire codebase)"],"output_types":["refactoring preview showing all affected files","updated code with consistent changes across files","dependency impact analysis","rollback capability"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-input__cap_8","uri":"capability://code.generation.editing.performance.profiling.and.optimization.suggestions","name":"performance profiling and optimization suggestions","description":"Analyzes code for performance bottlenecks by examining algorithmic complexity, memory usage patterns, and resource allocation. Generates optimization suggestions with estimated performance improvements, such as algorithm changes, caching strategies, or parallelization opportunities. Integrates with runtime profiling data to identify hot paths and correlate code patterns with performance issues.","intents":["I want the AI to identify performance bottlenecks in my code without running profilers","I need suggestions for optimizing slow functions with estimated performance improvements","I want to understand the algorithmic complexity of my code and how to improve it"],"best_for":["Performance-critical applications (real-time systems, high-throughput services)","Teams optimizing for specific metrics (latency, throughput, memory usage)","Developers who want to learn optimization techniques and best practices"],"limitations":["Static analysis can identify obvious inefficiencies but may miss subtle performance issues that require runtime profiling","Optimization suggestions are heuristic-based; actual performance improvements depend on runtime conditions and data characteristics","Some optimizations (e.g., parallelization) may introduce complexity or concurrency bugs that require careful review"],"requires":["Codebase context for understanding code structure","Optional: runtime profiling data (CPU profiles, memory traces) for correlation","Language-specific complexity analysis tools"],"input_types":["source code files","runtime profiling data (optional)","performance metrics or SLOs"],"output_types":["identified performance bottlenecks with severity","optimization suggestions with code examples","estimated performance improvements (percentage or absolute)","complexity analysis (Big O notation)"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-input__cap_9","uri":"capability://safety.moderation.security.vulnerability.detection.and.remediation","name":"security vulnerability detection and remediation","description":"Scans code for security vulnerabilities (injection attacks, authentication flaws, insecure dependencies) using pattern matching, data flow analysis, and known vulnerability databases. Generates remediation suggestions with code examples and severity ratings. Integrates with dependency scanning to identify vulnerable libraries and suggests updates or alternative libraries.","intents":["I want to identify security vulnerabilities in my code before they reach production","I need to understand the security implications of my code and how to fix them","I want to keep my dependencies up-to-date and avoid known vulnerabilities"],"best_for":["Security-sensitive applications (financial services, healthcare, authentication systems)","Teams with compliance requirements (OWASP, PCI-DSS, HIPAA)","Open-source projects that need to maintain security standards"],"limitations":["Pattern-based detection may have false positives or miss novel attack vectors","Data flow analysis is limited to static code; runtime behavior and configuration may introduce vulnerabilities not detected by static analysis","Dependency scanning relies on vulnerability databases; zero-day vulnerabilities may not be detected"],"requires":["Codebase context for data flow analysis","Access to vulnerability databases (CVE, NVD, etc.)","Dependency manifest files (package.json, requirements.txt, etc.)"],"input_types":["source code files","dependency manifests","configuration files"],"output_types":["identified vulnerabilities with severity ratings (CVSS)","remediation suggestions with code examples","vulnerable dependency reports with update recommendations","compliance mapping (OWASP, CWE, etc.)"],"categories":["safety-moderation","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":25,"verified":false,"data_access_risk":"high","permissions":["VS Code 1.70+ or compatible web editor","Active internet connection for AI model inference","Project codebase accessible to the AI agent (local or cloud-based)","Codebase accessible to Input (local or cloud-synced)","Supported language parsers for AST extraction (JavaScript, TypeScript, Python, Go, Rust, Java, C#)","Sufficient disk space for index storage (typically 10-20% of source code size)","Full codebase indexing with AST-based symbol extraction","Type information (from type annotations, type stubs, or type inference)","IDE integration (VS Code, JetBrains, etc.)","Team participation and willingness to document decisions"],"failure_modes":["Real-time collaboration latency depends on network conditions; high-latency connections may cause suggestion delays >500ms","AI suggestions are context-aware only within the current file and immediate imports; cross-service understanding requires explicit codebase indexing","Concurrent edits from multiple users may cause suggestion staleness if the AI model processes stale AST snapshots","Initial indexing of large codebases (>100k lines) may take 5-15 minutes; incremental updates are faster but still add latency","Vector-based retrieval may miss relevant code if semantic similarity is low; requires tuning of embedding model and similarity thresholds","Indexing requires read access to all source files; private or encrypted code may not be indexed correctly","Symbol resolution accuracy depends on type information; dynamically-typed code or reflection may not resolve correctly","Cross-language navigation (e.g., JavaScript calling Python APIs) requires multi-language support","Performance may degrade for very large codebases (>1M lines) without proper indexing and caching","Knowledge base quality depends on team participation and documentation discipline; incomplete or outdated knowledge reduces effectiveness","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.35,"ecosystem":0.25,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.1,"match_graph":0.35,"freshness":0.05}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-06-17T09:51:03.042Z","last_scraped_at":"2026-05-03T14:00:10.321Z","last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=input","compare_url":"https://unfragile.ai/compare?artifact=input"}},"signature":"MxN3i6pJZKGywNbu1mM2c9Y4jNc+Rwth2QhHHYE4nYBNQFTPqaeeUIbWf37/OwA47HVXMxrdg4MKuRP+w6yVAA==","signedAt":"2026-06-22T03:39:56.672Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/input","artifact":"https://unfragile.ai/input","verify":"https://unfragile.ai/api/v1/verify?slug=input","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"}}