{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"openrouter-qwen-qwen3-coder-30b-a3b-instruct","slug":"qwen-qwen3-coder-30b-a3b-instruct","name":"Qwen: Qwen3 Coder 30B A3B Instruct","type":"model","url":"https://openrouter.ai/models/qwen~qwen3-coder-30b-a3b-instruct","page_url":"https://unfragile.ai/qwen-qwen3-coder-30b-a3b-instruct","categories":["model-training"],"tags":["qwen","api-access","text"],"pricing":{"model":"paid","free":false,"starting_price":"$7.00e-8 per prompt token"},"status":"active","verified":false},"capabilities":[{"id":"openrouter-qwen-qwen3-coder-30b-a3b-instruct__cap_0","uri":"capability://code.generation.editing.repository.scale.code.understanding.and.generation","name":"repository-scale code understanding and generation","description":"Generates code with awareness of multi-file repository context by leveraging a 30.5B parameter Mixture-of-Experts architecture with 128 experts (8 active per forward pass), enabling efficient processing of large codebases without full context loading. The MoE design allows selective expert activation for different code domains (e.g., frontend vs backend patterns), reducing computational overhead while maintaining semantic coherence across file boundaries.","intents":["Generate code that respects existing repository patterns and conventions across multiple files","Understand and refactor large codebases without losing context of interdependencies","Complete complex multi-file features that require knowledge of existing architecture"],"best_for":["teams building large-scale applications requiring consistent code generation across repositories","developers refactoring monolithic codebases with complex interdependencies","engineering teams needing code generation that respects architectural patterns"],"limitations":["MoE routing overhead adds ~50-100ms per generation compared to dense models of equivalent parameter count","Expert specialization requires careful prompt engineering to activate relevant experts; generic prompts may not route to optimal experts","Context window limitations mean very large repositories still require selective file inclusion strategies","No built-in codebase indexing — requires external tools (e.g., tree-sitter, LSP) to extract and structure repository context"],"requires":["API access via OpenRouter or compatible inference endpoint","Minimum context window of 4K tokens (recommended 8K+ for multi-file scenarios)","Code repository in accessible format (files, git history, or structured AST representation)"],"input_types":["code snippets","full source files","repository file listings with paths","natural language specifications","git diffs and commit messages"],"output_types":["generated code","code completions","refactored code","code explanations","structured code analysis"],"categories":["code-generation-editing","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openrouter-qwen-qwen3-coder-30b-a3b-instruct__cap_1","uri":"capability://tool.use.integration.agentic.tool.use.with.structured.function.calling","name":"agentic tool use with structured function calling","description":"Supports function calling and tool orchestration through structured schema-based interfaces, enabling the model to invoke external APIs, libraries, and system commands as part of code generation and reasoning workflows. The model is trained to parse tool schemas, generate valid function calls with appropriate parameters, and reason about tool sequencing for multi-step tasks.","intents":["Generate code that calls external APIs with correct parameter binding and error handling","Orchestrate multi-step workflows by chaining tool calls (e.g., fetch data → transform → write to database)","Build autonomous agents that decide which tools to use based on task requirements"],"best_for":["developers building LLM-powered agents that need to interact with external systems","teams creating code generation tools that must integrate with build systems, package managers, and APIs","builders prototyping autonomous workflows that require tool composition and error recovery"],"limitations":["Tool schema complexity affects generation quality; overly complex schemas may cause parameter binding errors","No built-in tool execution sandbox — requires external runtime to safely execute generated tool calls","Tool hallucination possible if training data lacks examples of specific tool combinations","Requires explicit tool schema definition; no automatic schema inference from code or documentation"],"requires":["Tool schema definitions in JSON Schema or OpenAPI format","Runtime environment capable of executing function calls (e.g., Node.js, Python, or API gateway)","Integration layer to parse model output and invoke actual tools"],"input_types":["tool schema definitions","natural language task descriptions","code context with available libraries","previous tool call results and error messages"],"output_types":["structured function calls (JSON)","parameter bindings","tool invocation sequences","error handling code"],"categories":["tool-use-integration","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openrouter-qwen-qwen3-coder-30b-a3b-instruct__cap_10","uri":"capability://code.generation.editing.performance.optimization.analysis.and.code.generation","name":"performance optimization analysis and code generation","description":"Analyzes code for performance bottlenecks and generates optimized implementations by identifying inefficient patterns, suggesting algorithmic improvements, and applying performance-enhancing transformations. The model reasons about time and space complexity, considers trade-offs between performance and readability, and generates code with performance characteristics explained.","intents":["Identify performance bottlenecks in code and suggest optimizations","Generate optimized implementations of algorithms with complexity analysis","Apply performance-enhancing patterns (caching, lazy evaluation, parallelization) appropriately"],"best_for":["performance-critical applications requiring optimization","teams building performance analysis and optimization tools","developers learning optimization techniques and best practices"],"limitations":["Performance analysis is based on static code analysis; actual performance depends on runtime characteristics and data","Optimization suggestions may trade off readability or maintainability for performance","No access to actual performance metrics or profiling data; suggestions are based on patterns","Optimization effectiveness varies by runtime environment and hardware"],"requires":["Source code in supported language","Optional: performance constraints or targets","Optional: profiling data or performance metrics","Optional: hardware or runtime environment specifications"],"input_types":["source code files","algorithm descriptions","performance constraints","profiling data or metrics"],"output_types":["optimized code","complexity analysis","optimization explanations","trade-off analysis","performance benchmarks"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openrouter-qwen-qwen3-coder-30b-a3b-instruct__cap_11","uri":"capability://code.generation.editing.api.design.and.contract.generation","name":"api design and contract generation","description":"Generates API designs, specifications, and contracts by analyzing code and requirements to produce well-structured, documented APIs. The model applies API design best practices, generates OpenAPI/GraphQL schemas, and creates client and server code that adheres to the specified contract.","intents":["Design RESTful or GraphQL APIs with proper structure and documentation","Generate OpenAPI specifications from code or requirements","Create client libraries and server implementations from API contracts"],"best_for":["teams building APIs and needing to maintain contracts and documentation","organizations implementing API-first development practices","developers building API design and generation tools"],"limitations":["Generated API designs may not align with all business requirements or constraints","API contract generation requires clear specifications; ambiguous requirements may produce suboptimal designs","No validation against actual usage patterns or client needs","Generated code may require customization for specific frameworks or deployment environments"],"requires":["API requirements or specifications","Optional: existing API examples or style guides","Optional: data models or schema definitions","Optional: target framework or technology stack"],"input_types":["natural language API requirements","data models or schemas","existing API examples","business logic or use cases"],"output_types":["API specifications (OpenAPI, GraphQL)","server code","client libraries","API documentation","example requests and responses"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openrouter-qwen-qwen3-coder-30b-a3b-instruct__cap_12","uri":"capability://code.generation.editing.database.schema.design.and.query.generation","name":"database schema design and query generation","description":"Designs database schemas and generates SQL queries by analyzing requirements and applying database design best practices. The model creates normalized schemas, generates efficient queries, and produces migration scripts while considering performance and maintainability implications.","intents":["Design database schemas from requirements with proper normalization and indexing","Generate SQL queries for common operations with performance optimization","Create database migrations and schema evolution scripts"],"best_for":["teams building data-intensive applications requiring optimized schemas","developers learning database design and SQL best practices","organizations automating database code generation"],"limitations":["Schema design quality depends on requirements clarity; incomplete requirements may result in suboptimal designs","Query optimization is based on patterns; actual performance depends on data distribution and indexes","No access to actual query execution plans or performance metrics","Database-specific optimizations may vary; generated code may require tuning for specific database systems"],"requires":["Database requirements or data models","Optional: target database system (PostgreSQL, MySQL, etc.)","Optional: performance constraints or SLAs","Optional: existing schema examples"],"input_types":["data model descriptions","business requirements","entity relationships","performance constraints"],"output_types":["SQL schema definitions","SQL queries","migration scripts","index recommendations","schema documentation"],"categories":["code-generation-editing","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openrouter-qwen-qwen3-coder-30b-a3b-instruct__cap_13","uri":"capability://code.generation.editing.infrastructure.and.deployment.code.generation","name":"infrastructure and deployment code generation","description":"Generates infrastructure-as-code and deployment configurations by analyzing application requirements and applying cloud-native best practices. The model produces Terraform, Docker, Kubernetes, and CI/CD configurations that are production-ready and follow security and operational best practices.","intents":["Generate Docker and Kubernetes configurations for containerized applications","Create Terraform or CloudFormation code for infrastructure provisioning","Generate CI/CD pipeline configurations for automated testing and deployment"],"best_for":["teams implementing infrastructure-as-code and DevOps practices","developers building deployment automation and infrastructure tools","organizations standardizing infrastructure and deployment patterns"],"limitations":["Generated configurations may require customization for specific environments or constraints","Security configurations depend on requirements; generated code may need security review","No validation against actual infrastructure or deployment requirements","Cloud-specific features and optimizations vary; generated code may require tuning for specific providers"],"requires":["Application requirements and architecture","Optional: target cloud provider or infrastructure platform","Optional: security and compliance requirements","Optional: existing infrastructure examples"],"input_types":["application architecture descriptions","deployment requirements","security and compliance requirements","existing infrastructure configurations"],"output_types":["Docker configurations","Kubernetes manifests","Terraform or CloudFormation code","CI/CD pipeline configurations","infrastructure documentation"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openrouter-qwen-qwen3-coder-30b-a3b-instruct__cap_2","uri":"capability://code.generation.editing.instruction.following.code.generation.with.domain.specific.reasoning","name":"instruction-following code generation with domain-specific reasoning","description":"Generates code by following detailed natural language instructions with domain-specific reasoning about implementation trade-offs, performance characteristics, and architectural patterns. The model applies instruction-tuning to balance multiple objectives (correctness, efficiency, readability, maintainability) and reason about when to apply specific patterns based on context.","intents":["Generate production-ready code from detailed specifications without requiring multiple iterations","Implement complex algorithms with explanations of design decisions and trade-offs","Adapt code generation based on specific constraints (performance, memory, compatibility)"],"best_for":["developers writing detailed specifications and expecting high-quality first-pass code generation","teams building code generation pipelines where instruction clarity directly impacts output quality","educators and technical writers creating code examples that require nuanced explanations"],"limitations":["Instruction quality directly impacts output quality; ambiguous or contradictory instructions may produce suboptimal code","Domain-specific reasoning is limited to patterns present in training data; novel or cutting-edge techniques may not be well-represented","No interactive refinement loop — requires re-prompting to adjust generated code rather than iterative feedback","Instruction following can be brittle with very long or complex specifications (>2K tokens)"],"requires":["Clear, detailed natural language instructions","Context about target language, framework, and constraints","Sufficient context window to include full specification (4K+ tokens recommended)"],"input_types":["natural language specifications","code requirements and constraints","performance or architectural guidelines","existing code patterns to follow"],"output_types":["generated code","implementation explanations","trade-off analysis","alternative implementations"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openrouter-qwen-qwen3-coder-30b-a3b-instruct__cap_3","uri":"capability://code.generation.editing.multi.language.code.generation.with.syntax.aware.completion","name":"multi-language code generation with syntax-aware completion","description":"Generates syntactically correct code across 40+ programming languages by maintaining language-specific syntax awareness and idiom knowledge. The model leverages training data spanning multiple language ecosystems to apply language-specific best practices, naming conventions, and error handling patterns appropriate to each language.","intents":["Generate code in any major programming language without language-specific prompt engineering","Complete code snippets while respecting language syntax rules and idioms","Translate or port code between languages while preserving intent and adapting to target language patterns"],"best_for":["polyglot teams working across multiple programming languages and frameworks","developers building code generation tools that must support diverse language ecosystems","organizations migrating code between languages or maintaining multi-language codebases"],"limitations":["Language support quality varies; mainstream languages (Python, JavaScript, Java, C++) have better coverage than niche languages","Syntax correctness is high but not guaranteed; generated code may require linting or compilation checks","Language-specific idioms and best practices are learned from training data; newer language features may not be well-represented","No built-in syntax validation — requires external linters or compilers to verify correctness"],"requires":["Target language specification in prompt","Awareness of language version or framework version if relevant","Optional: language-specific context (imports, type definitions, existing code style)"],"input_types":["code snippets in any language","natural language descriptions of desired code","existing code in source language (for translation tasks)","language-specific constraints or style guides"],"output_types":["syntactically correct code","language-idiomatic implementations","translated code","code completions"],"categories":["code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openrouter-qwen-qwen3-coder-30b-a3b-instruct__cap_4","uri":"capability://code.generation.editing.code.review.and.quality.analysis.with.architectural.feedback","name":"code review and quality analysis with architectural feedback","description":"Analyzes code for quality issues, security vulnerabilities, performance problems, and architectural concerns by applying learned patterns from code review practices and best practices. The model identifies issues, explains their impact, and suggests improvements while considering the broader architectural context of the code.","intents":["Automatically review code changes for common issues before human review","Identify security vulnerabilities and suggest fixes with explanation","Analyze code for performance problems and suggest optimizations with trade-off analysis"],"best_for":["development teams implementing automated code review as part of CI/CD pipelines","security-conscious teams needing automated vulnerability scanning with context-aware suggestions","teams building code quality tools that require architectural understanding"],"limitations":["Review quality depends on code context; isolated snippets may miss architectural issues","False positives possible for domain-specific patterns or intentional design choices","Security analysis is pattern-based; novel or zero-day vulnerabilities may not be detected","No access to runtime behavior or actual performance metrics; suggestions are based on static analysis"],"requires":["Source code in text format","Optional: context about code purpose, constraints, and architectural patterns","Optional: style guides or review criteria to customize analysis"],"input_types":["source code files","code diffs or pull requests","code snippets with context","architectural documentation or patterns"],"output_types":["issue identification and categorization","severity assessment","suggested fixes with explanations","architectural feedback","performance analysis"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openrouter-qwen-qwen3-coder-30b-a3b-instruct__cap_5","uri":"capability://code.generation.editing.debugging.and.error.diagnosis.with.contextual.explanations","name":"debugging and error diagnosis with contextual explanations","description":"Diagnoses code errors and bugs by analyzing error messages, stack traces, and code context to identify root causes and suggest fixes. The model correlates error symptoms with common patterns, considers the broader code context, and provides explanations of why errors occur and how to prevent them.","intents":["Understand error messages and stack traces to identify root causes quickly","Generate fixes for common bugs with explanations of what went wrong","Learn from errors by understanding underlying causes and prevention strategies"],"best_for":["developers debugging complex issues in large codebases","teams building AI-assisted debugging tools or IDE integrations","junior developers learning to diagnose and fix errors systematically"],"limitations":["Diagnosis accuracy depends on error message quality and code context provided","Runtime-specific issues (memory leaks, race conditions) may not be detectable from static code analysis","Requires sufficient context to understand error origin; minimal stack traces may lead to incorrect diagnosis","No access to actual runtime state or logs; suggestions are based on patterns and code analysis"],"requires":["Error message or stack trace","Relevant source code context","Optional: reproduction steps or test cases","Optional: runtime environment details (language version, framework, dependencies)"],"input_types":["error messages and stack traces","source code files","test cases or reproduction steps","runtime environment information"],"output_types":["root cause analysis","suggested fixes","explanations of error causes","prevention strategies","test cases to verify fixes"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openrouter-qwen-qwen3-coder-30b-a3b-instruct__cap_6","uri":"capability://code.generation.editing.test.generation.and.test.case.reasoning","name":"test generation and test case reasoning","description":"Generates comprehensive test cases by analyzing code to identify edge cases, boundary conditions, and error scenarios. The model reasons about test coverage, applies testing best practices, and generates tests in appropriate frameworks while considering the code's purpose and constraints.","intents":["Generate unit tests automatically from source code with good coverage","Identify edge cases and boundary conditions that should be tested","Create integration tests that verify interactions between components"],"best_for":["teams implementing test-driven development or improving test coverage","developers building code generation tools that include test generation","organizations automating test creation as part of CI/CD pipelines"],"limitations":["Test quality depends on code clarity; poorly documented code may result in incomplete test coverage","Generated tests may not cover all business logic requirements; human review is recommended","Mock and fixture generation can be complex for external dependencies; may require manual adjustment","No understanding of actual business requirements; tests are based on code structure alone"],"requires":["Source code in supported language","Optional: test framework specification (Jest, pytest, JUnit, etc.)","Optional: existing test examples to match style and patterns","Optional: documentation of business logic or requirements"],"input_types":["source code files","function or method signatures","code documentation and comments","existing test examples"],"output_types":["unit test code","integration test code","test fixtures and mocks","test coverage analysis","edge case identification"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openrouter-qwen-qwen3-coder-30b-a3b-instruct__cap_7","uri":"capability://text.generation.language.documentation.generation.and.code.explanation","name":"documentation generation and code explanation","description":"Generates documentation and explanations by analyzing code structure, logic, and intent to produce clear, accurate descriptions. The model creates documentation in multiple formats (docstrings, README sections, API documentation) while explaining complex logic and design decisions in natural language.","intents":["Generate docstrings and inline comments that explain code purpose and behavior","Create API documentation from code signatures and implementations","Explain complex algorithms and design patterns in natural language"],"best_for":["teams improving code documentation coverage and quality","developers building code generation tools that include documentation","open-source projects needing to maintain comprehensive documentation"],"limitations":["Documentation quality depends on code clarity; poorly structured code may result in unclear documentation","Generated documentation may miss important context or business logic not evident from code","Docstring format varies by language and convention; requires specification or examples","No access to actual usage patterns or user feedback; documentation is based on code structure alone"],"requires":["Source code in supported language","Optional: documentation style guide or examples","Optional: context about code purpose and intended audience","Optional: existing documentation to match tone and style"],"input_types":["source code files","function or class signatures","code comments and existing documentation","documentation style guides"],"output_types":["docstrings","inline comments","API documentation","README sections","architecture documentation"],"categories":["text-generation-language","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openrouter-qwen-qwen3-coder-30b-a3b-instruct__cap_8","uri":"capability://code.generation.editing.code.refactoring.with.pattern.aware.transformations","name":"code refactoring with pattern-aware transformations","description":"Refactors code by identifying improvement opportunities and applying transformations while preserving behavior and intent. The model recognizes anti-patterns, suggests design improvements, and generates refactored code that maintains backward compatibility or manages breaking changes appropriately.","intents":["Improve code quality by identifying and fixing anti-patterns and code smells","Modernize code by applying contemporary language features and frameworks","Restructure code to improve maintainability and reduce complexity"],"best_for":["teams maintaining legacy codebases and planning modernization","developers improving code quality as part of regular maintenance","organizations building refactoring tools or IDE integrations"],"limitations":["Refactoring safety depends on test coverage; untested code may have hidden behavior changes","Large refactorings may introduce subtle bugs; human review is recommended","Refactoring suggestions are based on patterns; domain-specific optimizations may be missed","No access to runtime behavior; performance improvements are based on static analysis"],"requires":["Source code in supported language","Optional: test suite to verify refactoring correctness","Optional: refactoring goals or constraints","Optional: target language version or framework version"],"input_types":["source code files","refactoring goals or constraints","existing test cases","architectural guidelines"],"output_types":["refactored code","refactoring explanations","migration guides for breaking changes","test updates"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"openrouter-qwen-qwen3-coder-30b-a3b-instruct__cap_9","uri":"capability://code.generation.editing.natural.language.to.code.translation.with.semantic.preservation","name":"natural language to code translation with semantic preservation","description":"Translates natural language specifications and descriptions into executable code while preserving semantic intent and applying appropriate design patterns. The model interprets ambiguous specifications, makes reasonable assumptions, and generates code that balances correctness with readability and maintainability.","intents":["Generate code from natural language specifications without manual coding","Translate pseudocode or algorithm descriptions into working implementations","Create code from user stories or requirements with minimal ambiguity"],"best_for":["non-technical stakeholders or product managers describing features in natural language","teams using specification-driven development with AI-assisted implementation","rapid prototyping scenarios where quick code generation is prioritized"],"limitations":["Specification quality directly impacts code quality; ambiguous descriptions may produce incorrect code","Generated code may not match all implicit requirements or business logic","No validation against actual requirements; generated code requires testing and review","Complex specifications may require multiple iterations to achieve desired behavior"],"requires":["Clear natural language specification","Optional: target language and framework","Optional: existing code examples or style guides","Optional: constraints or non-functional requirements"],"input_types":["natural language descriptions","user stories","pseudocode","algorithm descriptions","requirements documents"],"output_types":["executable code","implementation explanations","assumptions and clarifications","alternative implementations"],"categories":["code-generation-editing","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":25,"verified":false,"data_access_risk":"high","permissions":["API access via OpenRouter or compatible inference endpoint","Minimum context window of 4K tokens (recommended 8K+ for multi-file scenarios)","Code repository in accessible format (files, git history, or structured AST representation)","Tool schema definitions in JSON Schema or OpenAPI format","Runtime environment capable of executing function calls (e.g., Node.js, Python, or API gateway)","Integration layer to parse model output and invoke actual tools","Source code in supported language","Optional: performance constraints or targets","Optional: profiling data or performance metrics","Optional: hardware or runtime environment specifications"],"failure_modes":["MoE routing overhead adds ~50-100ms per generation compared to dense models of equivalent parameter count","Expert specialization requires careful prompt engineering to activate relevant experts; generic prompts may not route to optimal experts","Context window limitations mean very large repositories still require selective file inclusion strategies","No built-in codebase indexing — requires external tools (e.g., tree-sitter, LSP) to extract and structure repository context","Tool schema complexity affects generation quality; overly complex schemas may cause parameter binding errors","No built-in tool execution sandbox — requires external runtime to safely execute generated tool calls","Tool hallucination possible if training data lacks examples of specific tool combinations","Requires explicit tool schema definition; no automatic schema inference from code or documentation","Performance analysis is based on static code analysis; actual performance depends on runtime characteristics and data","Optimization suggestions may trade off readability or maintainability for performance","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.5,"ecosystem":0.24,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.35,"quality":0.2,"ecosystem":0.1,"match_graph":0.3,"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-05-24T12:16:24.485Z","last_scraped_at":"2026-05-03T15:20:45.776Z","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=qwen-qwen3-coder-30b-a3b-instruct","compare_url":"https://unfragile.ai/compare?artifact=qwen-qwen3-coder-30b-a3b-instruct"}},"signature":"J4GQlKI2JnPD0GkQSJwR6taIXXCQauMpH9WhneBVdBnzuWl/CInmu6f1JcKmVlcWXOvtqtI3zq46RCNMzNe4BA==","signedAt":"2026-06-21T14:27:47.241Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/qwen-qwen3-coder-30b-a3b-instruct","artifact":"https://unfragile.ai/qwen-qwen3-coder-30b-a3b-instruct","verify":"https://unfragile.ai/api/v1/verify?slug=qwen-qwen3-coder-30b-a3b-instruct","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"}}