{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"qwen2-5-coder-32b","slug":"qwen2-5-coder-32b","name":"Qwen2.5-Coder 32B","type":"model","url":"https://qwenlm.github.io/blog/qwen2.5-coder-family/","page_url":"https://unfragile.ai/qwen2-5-coder-32b","categories":["model-training"],"tags":[],"pricing":{"model":"free","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"qwen2-5-coder-32b__cap_0","uri":"capability://code.generation.editing.multi.language.code.generation.with.40.language.support","name":"multi-language code generation with 40+ language support","description":"Generates syntactically correct code across 40+ programming languages (Python, JavaScript, TypeScript, Java, C++, Go, Rust, Haskell, Racket, and others) using a transformer-based architecture trained on 5.5 trillion tokens with heavy code data mixture. The model learns language-specific syntax, idioms, and patterns through instruction-tuning, enabling it to produce contextually appropriate code for diverse language ecosystems without language-specific fine-tuning branches.","intents":["Generate boilerplate code in languages I'm less familiar with","Complete code snippets across multiple languages in a single codebase","Translate algorithm logic from one language to another","Generate code for less common languages like Haskell or Racket"],"best_for":["polyglot development teams working across multiple language ecosystems","developers building language-agnostic code generation tools","teams migrating codebases between languages"],"limitations":["Performance varies by language — McEval shows 65.9% accuracy across 40+ languages, indicating lower accuracy for less common languages","No guarantee of code correctness or best practices for domain-specific languages","Context window of 128K tokens limits repository-level understanding for very large codebases"],"requires":["Model weights (32B parameters requires ~64GB GPU VRAM for full precision, specific quantization options unknown)","Inference framework supporting transformer models (vLLM, llama.cpp, or similar)","Input prompt formatted as instruction-following text"],"input_types":["text prompts","code snippets with context","natural language specifications"],"output_types":["code text","multi-file code generation (via 128K context window)"],"categories":["code-generation-editing","polyglot-development"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"qwen2-5-coder-32b__cap_1","uri":"capability://code.generation.editing.code.repair.and.debugging.with.repository.level.context","name":"code repair and debugging with repository-level context","description":"Identifies and fixes bugs in existing code by leveraging a 128K token context window to understand repository-level patterns, dependencies, and error contexts. Uses instruction-tuned transformer architecture to reason about code execution flow, predict error causes, and generate corrected code that maintains consistency with surrounding codebase patterns. Achieves 73.7% on Aider benchmark, comparable to GPT-4o.","intents":["Fix compilation errors and runtime exceptions in existing code","Refactor buggy code while preserving intended functionality","Understand why code fails and generate corrected versions","Apply fixes across multiple files in a repository context"],"best_for":["developers debugging production code with access to full repository context","teams building automated code repair tools or IDE plugins","CI/CD pipelines that need to suggest fixes for failing tests"],"limitations":["Aider benchmark score of 73.7% indicates ~26% failure rate on real-world code repair tasks","No explicit safety guarantees — generated fixes may introduce new bugs or security vulnerabilities","Performance depends on quality of error messages and surrounding context provided","Limited to code repair; does not execute code to verify fixes"],"requires":["Model weights (32B parameters)","Error context or failing test output as input","Repository files within 128K token context window","Inference framework with support for long context windows"],"input_types":["buggy code snippets","error messages and stack traces","test failures","repository context files"],"output_types":["corrected code","explanation of bug and fix","multi-file patches"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"qwen2-5-coder-32b__cap_10","uri":"capability://code.generation.editing.test.case.generation.and.unit.test.writing","name":"test case generation and unit test writing","description":"Generates unit tests and test cases from code specifications by understanding function behavior and edge cases through semantic analysis. The model learns testing patterns and common edge cases from training data, enabling it to generate comprehensive test suites that cover normal cases, edge cases, and error conditions.","intents":["Auto-generate unit tests for existing functions","Create test cases for new features from specifications","Generate edge case tests for robustness","Improve test coverage by identifying untested code paths"],"best_for":["teams improving test coverage in legacy codebases","test-driven development workflows","CI/CD pipelines enforcing minimum test coverage"],"limitations":["Generated tests may not cover all edge cases or failure modes","Test quality depends on understanding of function behavior — may miss subtle bugs","Cannot generate tests for code with external dependencies without mocking context","No mechanism to verify generated tests actually pass"],"requires":["Model weights (32B parameters)","Function or module specification as input","Optional: existing test examples for pattern learning","Testing framework context (Jest, pytest, JUnit, etc.)"],"input_types":["function signatures","code to test","specifications"],"output_types":["test code","test cases","edge case specifications"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"qwen2-5-coder-32b__cap_11","uri":"capability://code.generation.editing.code.optimization.and.performance.improvement.suggestions","name":"code optimization and performance improvement suggestions","description":"Analyzes code for performance bottlenecks and suggests optimizations by understanding algorithmic complexity, memory usage patterns, and language-specific performance characteristics. The model learns optimization patterns from training data and recommends changes that improve performance while maintaining correctness.","intents":["Identify performance bottlenecks in code","Suggest algorithmic improvements (e.g., O(n²) to O(n log n))","Recommend language-specific optimizations","Explain performance implications of code changes"],"best_for":["performance-critical applications needing optimization","code review tools analyzing performance implications","teams migrating code to performance-sensitive environments"],"limitations":["Performance analysis requires understanding of runtime characteristics — may miss subtle bottlenecks","Optimization suggestions may not be applicable without profiling data","Cannot optimize for hardware-specific characteristics without explicit context","No mechanism to verify performance improvements actually occur"],"requires":["Model weights (32B parameters)","Code to optimize as input","Optional: performance profiling data or bottleneck context"],"input_types":["code snippets","performance profiles","bottleneck descriptions"],"output_types":["optimization suggestions","refactored code","complexity analysis"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"qwen2-5-coder-32b__cap_12","uri":"capability://safety.moderation.security.vulnerability.detection.and.remediation.suggestion","name":"security vulnerability detection and remediation suggestion","description":"Identifies potential security vulnerabilities in code by recognizing dangerous patterns and unsafe API usage learned from training data. The model understands common vulnerability classes (SQL injection, XSS, buffer overflow, etc.) and suggests secure alternatives or remediation strategies.","intents":["Identify potential security vulnerabilities in code reviews","Suggest secure alternatives to unsafe API usage","Explain security implications of code patterns","Generate secure code implementations"],"best_for":["security-focused code review processes","CI/CD pipelines enforcing security standards","teams building security-critical applications"],"limitations":["Vulnerability detection relies on learned patterns — may miss novel or complex vulnerabilities","Cannot detect vulnerabilities requiring domain-specific knowledge (e.g., cryptographic weaknesses)","No explicit security benchmark provided — capability inferred from general code understanding","False positives and false negatives likely — should not replace dedicated security scanners"],"requires":["Model weights (32B parameters)","Code to analyze as input","Optional: security context or vulnerability class hints"],"input_types":["code snippets","full files","security concern descriptions"],"output_types":["vulnerability descriptions","remediation suggestions","secure code examples"],"categories":["safety-moderation","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"qwen2-5-coder-32b__cap_13","uri":"capability://text.generation.language.code.explanation.and.documentation.understanding","name":"code explanation and documentation understanding","description":"Explains code functionality and behavior in natural language by understanding code semantics through transformer-based analysis. The model traces execution flow, explains variable usage, and describes what code does in clear, human-readable language suitable for documentation, code reviews, or learning.","intents":["Understand what unfamiliar code does","Explain code behavior to non-technical stakeholders","Generate natural language descriptions of code for documentation","Learn how code implements specific algorithms or patterns"],"best_for":["code review tools providing context and explanations","educational platforms teaching programming concepts","documentation generation systems","developers onboarding to unfamiliar codebases"],"limitations":["Explanation quality depends on code clarity — may produce confusing explanations for poorly written code","Cannot explain code relying on external libraries without documentation context","Explanations may be overly verbose or miss important details","No mechanism to verify explanation accuracy"],"requires":["Model weights (32B parameters)","Code to explain as input","Optional: context about code purpose or domain"],"input_types":["code snippets","functions","algorithms"],"output_types":["natural language explanations","step-by-step descriptions","behavior summaries"],"categories":["text-generation-language","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"qwen2-5-coder-32b__cap_14","uri":"capability://automation.workflow.open.source.model.deployment.with.apache.2.0.commercial.licensing","name":"open-source model deployment with apache 2.0 commercial licensing","description":"Provides fully open-source model weights under Apache 2.0 license enabling unrestricted commercial use, self-hosting, and fine-tuning. Model is distributed via multiple channels (GitHub, Hugging Face, ModelScope, Kaggle) with support for various inference frameworks and quantization formats, enabling flexible deployment in any environment without licensing restrictions.","intents":["Deploy code generation model in private/on-premise environments","Fine-tune model on proprietary code for domain-specific performance","Integrate model into commercial products without licensing fees","Avoid vendor lock-in by using open-source model"],"best_for":["enterprises requiring on-premise deployment for data privacy","teams building commercial products using code generation","organizations seeking to avoid cloud vendor lock-in","researchers fine-tuning models for specialized domains"],"limitations":["Self-hosting requires significant GPU infrastructure (32B model requires ~64GB VRAM for full precision)","Quantization options not documented — unclear which formats are officially supported","No commercial support or SLA provided — community-driven support only","Model updates and versioning strategy not documented"],"requires":["GPU infrastructure with sufficient VRAM (64GB+ for full precision, 16GB+ for quantized versions)","Inference framework (vLLM, llama.cpp, Ollama, etc.)","Model weights from distribution channels (Hugging Face, GitHub, ModelScope, Kaggle)","Optional: fine-tuning infrastructure for domain-specific adaptation"],"input_types":["model weights","inference configuration"],"output_types":["deployed inference service","fine-tuned model variants"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"qwen2-5-coder-32b__cap_15","uri":"capability://code.generation.editing.code.generation.for.specific.frameworks.and.libraries","name":"code generation for specific frameworks and libraries","description":"Generates code using specific frameworks and libraries with correct API usage and patterns. The model understands framework-specific conventions (React hooks, Django ORM, Spring Boot annotations, Express.js middleware) and generates code that follows framework idioms. Trained on real-world framework usage patterns.","intents":["Generate a React component using hooks and proper state management patterns","Create a Django model with correct ORM relationships and validation","Generate a Spring Boot REST controller with proper annotations and error handling","Create an Express.js middleware for authentication and authorization"],"best_for":["Developers working with specific frameworks and needing rapid code generation","Teams standardizing on particular frameworks and needing consistent implementations","Rapid prototyping with framework-specific patterns"],"limitations":["Framework knowledge is limited to training data — may be outdated for new framework versions","Cannot generate code for custom or proprietary frameworks not in training data","May generate code that works but doesn't follow current framework best practices","Performance and scalability implications of generated code unknown"],"requires":["Framework and version specification","Framework documentation or examples to match style","Understanding of framework-specific patterns and conventions"],"input_types":["framework specification","feature requirements","existing framework code examples","framework configuration files"],"output_types":["framework-specific code","components or modules using framework patterns","configuration files"],"categories":["code-generation-editing","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"qwen2-5-coder-32b__cap_2","uri":"capability://planning.reasoning.code.reasoning.and.execution.flow.prediction","name":"code reasoning and execution flow prediction","description":"Predicts code execution flow, output values, and behavior by reasoning about program semantics using transformer-based chain-of-thought patterns learned during instruction-tuning. The model traces variable assignments, control flow branches, and function calls to forecast what code will produce without executing it, enabling static analysis and correctness verification.","intents":["Predict what a code snippet will output without running it","Trace execution flow through complex control structures","Identify unreachable code or logical inconsistencies","Verify code correctness before deployment"],"best_for":["code review tools that need to explain code behavior","static analysis platforms augmenting traditional linters","educational tools teaching programming concepts"],"limitations":["No explicit benchmark provided for code reasoning accuracy — inferred from general capability claims","Cannot reason about external dependencies or library behavior without documentation","Limited to deterministic code paths — cannot predict behavior with randomness or external I/O","Reasoning quality degrades with code complexity and nested control structures"],"requires":["Model weights (32B parameters)","Code snippet as text input","Optional: variable initialization context"],"input_types":["code snippets","function definitions","control flow examples"],"output_types":["predicted output values","execution trace explanation","control flow analysis"],"categories":["planning-reasoning","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"qwen2-5-coder-32b__cap_3","uri":"capability://code.generation.editing.instruction.following.code.generation.with.context.preservation","name":"instruction-following code generation with context preservation","description":"Generates code based on natural language instructions while preserving existing code context and style through instruction-tuned transformer architecture. The model learns to parse multi-turn conversations, follow specific coding conventions, and maintain consistency with surrounding code patterns. Supports repository-level understanding via 128K context window, enabling context-aware generation that respects existing architecture and naming conventions.","intents":["Generate code from natural language specifications while matching existing codebase style","Follow multi-step instructions to build complex features","Generate code that integrates seamlessly with existing modules","Maintain coding conventions and patterns across generated code"],"best_for":["IDE plugins and code assistants that need to understand user intent","code generation APIs serving web-based code editors","teams building internal code generation tools with custom style guides"],"limitations":["Instruction-following quality depends on prompt clarity and context quality","No explicit mechanism to enforce style guide compliance — relies on learned patterns","128K context window may be insufficient for very large repositories (>50K lines)","No built-in version control awareness — cannot track changes or maintain edit history"],"requires":["Model weights (32B parameters)","Natural language instruction as input","Optional: existing code context within 128K token limit","Inference framework supporting instruction-following models"],"input_types":["natural language instructions","code context","multi-turn conversation history"],"output_types":["generated code","code modifications","multi-file code generation"],"categories":["code-generation-editing","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"qwen2-5-coder-32b__cap_4","uri":"capability://memory.knowledge.repository.level.code.understanding.with.128k.context.window","name":"repository-level code understanding with 128k context window","description":"Processes up to 128K tokens of repository context to understand cross-file dependencies, module relationships, and architectural patterns. The transformer architecture maintains attention across the full context window, enabling the model to reason about how code changes in one file affect other files and to generate code that respects repository-wide constraints and patterns.","intents":["Generate code that integrates with multiple modules in a repository","Understand how changes in one file impact other files","Refactor code while maintaining consistency across the codebase","Generate code that respects architectural patterns and design decisions"],"best_for":["large monorepo teams needing context-aware code generation","refactoring tools that need to understand cross-file impact","code review assistants analyzing changes in architectural context"],"limitations":["128K token limit (~100K lines of code) insufficient for very large repositories (>500K lines)","Context selection strategy not documented — unclear how model prioritizes relevant files","Attention mechanism may struggle with very large context windows (128K tokens approaches typical transformer limits)","No explicit mechanism to handle circular dependencies or complex module graphs"],"requires":["Model weights (32B parameters)","Repository files totaling <128K tokens","Inference framework supporting long context windows (vLLM, llama.cpp with long context support)","Context selection strategy (manual or automated file selection)"],"input_types":["multiple code files","repository structure metadata","dependency graphs"],"output_types":["context-aware code generation","cross-file refactoring suggestions","architectural analysis"],"categories":["memory-knowledge","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"qwen2-5-coder-32b__cap_5","uri":"capability://code.generation.editing.code.generation.with.mathematical.and.logical.reasoning","name":"code generation with mathematical and logical reasoning","description":"Generates code for mathematical algorithms and logical problems by combining code generation with mathematical reasoning learned during training on 5.5 trillion tokens. The model understands mathematical notation, algorithm correctness, and logical proofs, enabling it to generate code that correctly implements complex algorithms without requiring separate mathematical reasoning modules.","intents":["Generate code for mathematical algorithms (sorting, graph algorithms, numerical methods)","Implement solutions to competitive programming problems","Generate code for scientific computing and data analysis","Verify mathematical correctness of generated code"],"best_for":["competitive programming platforms and coding interview preparation tools","scientific computing environments needing algorithm implementation","educational platforms teaching algorithms and data structures"],"limitations":["Mathematical reasoning capability not separately benchmarked — inferred from general capability claims","No explicit support for symbolic mathematics or formal verification","Numerical precision and floating-point correctness not guaranteed","Complex mathematical proofs may exceed model's reasoning capacity"],"requires":["Model weights (32B parameters)","Problem specification in natural language or pseudocode","Optional: mathematical context or algorithm hints"],"input_types":["problem descriptions","mathematical specifications","pseudocode"],"output_types":["code implementations","algorithm explanations","complexity analysis"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"qwen2-5-coder-32b__cap_6","uri":"capability://code.generation.editing.code.completion.with.syntax.aware.token.prediction","name":"code completion with syntax-aware token prediction","description":"Completes code snippets by predicting the next tokens using transformer-based language modeling with syntax awareness learned from code-heavy training data. The model learns programming language syntax, common patterns, and idiomatic code structures, enabling it to suggest contextually appropriate completions that respect language grammar and project conventions.","intents":["Auto-complete code as I type in an IDE","Suggest next lines of code based on context","Complete function signatures and method calls","Fill in boilerplate code patterns"],"best_for":["IDE plugins and code editors (VS Code, JetBrains, etc.)","real-time code completion services","developers seeking faster coding velocity"],"limitations":["Completion quality depends on context window size and preceding code quality","No explicit latency benchmarks provided — inference speed unknown","May suggest incorrect completions for ambiguous contexts","No mechanism to enforce project-specific naming conventions or style guides"],"requires":["Model weights (32B parameters)","Preceding code context (within 128K token limit)","Low-latency inference framework (vLLM, TensorRT, or similar)","IDE integration layer"],"input_types":["partial code snippets","cursor position context"],"output_types":["token predictions","completion suggestions","ranked candidate completions"],"categories":["code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"qwen2-5-coder-32b__cap_7","uri":"capability://code.generation.editing.code.review.and.quality.analysis.with.semantic.understanding","name":"code review and quality analysis with semantic understanding","description":"Analyzes code for quality issues, style violations, and potential bugs by understanding code semantics through transformer-based pattern recognition. The model learns common code smells, anti-patterns, and best practices from training data, enabling it to identify issues without explicit rule-based linting. Provides explanations for identified issues and suggests improvements.","intents":["Identify code quality issues and anti-patterns in pull requests","Suggest code improvements and refactoring opportunities","Explain why code may be problematic or inefficient","Enforce coding standards and best practices"],"best_for":["code review automation in CI/CD pipelines","pull request analysis tools","teams seeking semantic code quality analysis beyond linting"],"limitations":["No explicit code review benchmark provided — capability inferred from general code understanding","Cannot detect security vulnerabilities requiring domain-specific knowledge (SQL injection, XSS, etc.)","Quality analysis depends on model's learned patterns — may miss domain-specific issues","No integration with static analysis tools or security scanners"],"requires":["Model weights (32B parameters)","Code to review as text input","Optional: coding standards or style guide context"],"input_types":["code snippets","full files","diffs or patches"],"output_types":["quality issues and explanations","improvement suggestions","refactoring recommendations"],"categories":["code-generation-editing","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"qwen2-5-coder-32b__cap_8","uri":"capability://code.generation.editing.cross.language.code.translation.and.porting","name":"cross-language code translation and porting","description":"Translates code from one programming language to another while preserving functionality and adapting to target language idioms. Uses transformer-based semantic understanding to map language-specific constructs (e.g., Python list comprehensions to JavaScript array methods) and generates idiomatic code in the target language rather than literal translations.","intents":["Port legacy code from one language to another","Translate algorithms across language ecosystems","Learn how to implement patterns in unfamiliar languages","Migrate codebases between language ecosystems"],"best_for":["teams migrating from one language to another (e.g., Python to Go)","polyglot organizations needing code translation","developers learning new languages by translating familiar code"],"limitations":["Translation quality varies significantly by language pair — no benchmarks provided","Cannot translate code relying on language-specific libraries without manual adaptation","Idiomatic translation requires understanding of both language ecosystems — may produce non-idiomatic code","Performance characteristics may differ significantly between translated versions"],"requires":["Model weights (32B parameters)","Source code in supported language","Target language specification","Optional: library mapping or API translation context"],"input_types":["source code","language pair specification"],"output_types":["translated code","translation notes and caveats"],"categories":["code-generation-editing","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"qwen2-5-coder-32b__cap_9","uri":"capability://text.generation.language.api.and.library.documentation.generation.from.code","name":"api and library documentation generation from code","description":"Generates comprehensive API documentation and docstrings from code by understanding function signatures, parameters, return types, and behavior through semantic analysis. The model learns documentation patterns from training data and generates documentation that explains what code does, how to use it, and what parameters mean.","intents":["Auto-generate docstrings for functions and classes","Create API documentation from source code","Generate README sections explaining code modules","Document code changes in pull requests"],"best_for":["teams maintaining large codebases with incomplete documentation","open-source projects seeking to improve documentation quality","CI/CD pipelines enforcing documentation standards"],"limitations":["Generated documentation may be inaccurate if code behavior is non-obvious","Cannot infer intent from poorly written code","Documentation quality depends on code clarity and structure","No mechanism to validate generated documentation against actual behavior"],"requires":["Model weights (32B parameters)","Code to document as text input","Optional: documentation style guide or template"],"input_types":["function definitions","class definitions","module code"],"output_types":["docstrings","API documentation","parameter descriptions"],"categories":["text-generation-language","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"qwen2-5-coder-32b__headline","uri":"capability://code.generation.editing.best.open.source.code.generation.model","name":"best open-source code generation model","description":"Qwen2.5-Coder 32B is an advanced open-source code generation model with 32 billion parameters, excelling in multiple programming languages and achieving top benchmarks in code generation tasks.","intents":["best open-source code generation model","open-source model for code completion","AI model for code repair","top coding model for multiple languages","best AI model for software development"],"best_for":["developers seeking open-source solutions","teams needing high-performance code generation"],"limitations":[],"requires":[],"input_types":[],"output_types":[],"categories":["code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":57,"verified":false,"data_access_risk":"high","permissions":["Model weights (32B parameters requires ~64GB GPU VRAM for full precision, specific quantization options unknown)","Inference framework supporting transformer models (vLLM, llama.cpp, or similar)","Input prompt formatted as instruction-following text","Model weights (32B parameters)","Error context or failing test output as input","Repository files within 128K token context window","Inference framework with support for long context windows","Function or module specification as input","Optional: existing test examples for pattern learning","Testing framework context (Jest, pytest, JUnit, etc.)"],"failure_modes":["Performance varies by language — McEval shows 65.9% accuracy across 40+ languages, indicating lower accuracy for less common languages","No guarantee of code correctness or best practices for domain-specific languages","Context window of 128K tokens limits repository-level understanding for very large codebases","Aider benchmark score of 73.7% indicates ~26% failure rate on real-world code repair tasks","No explicit safety guarantees — generated fixes may introduce new bugs or security vulnerabilities","Performance depends on quality of error messages and surrounding context provided","Limited to code repair; does not execute code to verify fixes","Generated tests may not cover all edge cases or failure modes","Test quality depends on understanding of function behavior — may miss subtle bugs","Cannot generate tests for code with external dependencies without mocking context","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.7,"quality":0.9,"ecosystem":0.3,"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:25.061Z","last_scraped_at":null,"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=qwen2-5-coder-32b","compare_url":"https://unfragile.ai/compare?artifact=qwen2-5-coder-32b"}},"signature":"6PebI5+NUl+Dr98Bfrm3+J6qctMmKlS0f2l4Y4jyCYXBlv5DtzS+ez4LkMfx21RVeY+ccyVBwRtt2wNqZ23UDg==","signedAt":"2026-06-21T10:40:33.415Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/qwen2-5-coder-32b","artifact":"https://unfragile.ai/qwen2-5-coder-32b","verify":"https://unfragile.ai/api/v1/verify?slug=qwen2-5-coder-32b","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"}}