{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"granite","slug":"granite","name":"Granite","type":"repo","url":"https://github.com/ibm-granite/granite-code-models","page_url":"https://unfragile.ai/granite","categories":["model-training"],"tags":[],"pricing":{"model":"free","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"granite__cap_0","uri":"capability://code.generation.editing.multilingual.code.generation.across.116.programming.languages","name":"multilingual code generation across 116 programming languages","description":"Generates syntactically correct and semantically meaningful code across 116 programming languages by leveraging a unified decoder-only transformer architecture trained on 3-4 trillion tokens of language-agnostic code data during Phase 1, followed by mixed code-language training in Phase 2. The model learns cross-language patterns and idioms through exposure to diverse codebases, enabling it to generate contextually appropriate code regardless of target language without language-specific tokenizers or specialized heads.","intents":["Generate boilerplate code in unfamiliar programming languages without manual syntax lookup","Translate code snippets between different languages while preserving logic and intent","Build polyglot systems that need code generation across heterogeneous tech stacks","Create language-agnostic code templates that can be instantiated in multiple languages"],"best_for":["Enterprise teams managing polyglot codebases (Java, Python, Go, Rust, etc.)","DevOps engineers automating infrastructure-as-code generation across multiple languages","Educational platforms teaching programming across multiple languages simultaneously"],"limitations":["Performance varies by language popularity in training data; less common languages (e.g., Cobol, Fortran) may have lower quality generations","No explicit language routing or language-specific prompting strategies built-in; requires manual prompt engineering to specify target language","Context window limited to 2K-8K tokens depending on model size, constraining multi-file code generation tasks","No real-time syntax validation; generated code may have subtle language-specific errors requiring post-generation linting"],"requires":["Model weights for chosen size variant (3B, 8B, 20B, or 34B parameters)","Inference framework supporting decoder-only transformer inference (vLLM, TensorRT-LLM, or similar)","GPU with sufficient VRAM (3B: 8GB, 8B: 16GB, 20B: 40GB, 34B: 80GB) or quantization support"],"input_types":["natural language code description or specification","partial code snippet with completion request","code in one language with instruction to translate to another"],"output_types":["complete code functions or modules","code snippets with explanatory comments","multi-language code variants"],"categories":["code-generation-editing","multilingual-support"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"granite__cap_1","uri":"capability://code.generation.editing.instruction.tuned.code.generation.with.git.commit.semantics","name":"instruction-tuned code generation with git commit semantics","description":"Fine-tunes base models on instruction datasets derived from Git commits paired with human-written instructions and synthetically generated code instruction data, enabling the model to follow natural language directives for code modification tasks. The instruction tuning process leverages commit messages as implicit task descriptions and diffs as ground-truth code transformations, teaching the model to understand intent-driven code changes rather than just pattern completion.","intents":["Generate code that follows specific user instructions (e.g., 'add error handling to this function')","Perform code refactoring tasks described in natural language (e.g., 'extract this logic into a separate function')","Implement feature requests described as prose specifications","Explain and justify code changes in the context of user intent"],"best_for":["Teams using instruction-based code generation in IDEs or chat interfaces","Developers who prefer natural language directives over prompt engineering","Organizations building internal code generation tools with domain-specific instructions"],"limitations":["Instruction tuning may reduce raw code completion performance on non-instruction tasks compared to base models","Synthetic instruction datasets may contain biases or unrealistic code patterns that propagate to generations","No explicit instruction validation; model may misinterpret ambiguous or conflicting instructions","Limited to instruction types seen during tuning; novel instruction patterns may not generalize well"],"requires":["Granite Code Instruct model variant (not base models)","Inference framework with instruction-following prompt templates","Understanding of effective prompt structure for code instructions"],"input_types":["natural language instruction with code context","code snippet + modification request","commit message + code diff (for training/fine-tuning)"],"output_types":["modified code following instruction","explanation of changes made","refactored code with preserved semantics"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"granite__cap_10","uri":"capability://code.generation.editing.code.editing.and.refactoring.with.semantic.preservation","name":"code editing and refactoring with semantic preservation","description":"Performs targeted code edits and refactoring operations (e.g., extract function, rename variables, restructure logic) while preserving code semantics and functionality. The model understands code structure and intent well enough to make surgical edits without breaking functionality, leveraging semantic understanding developed during training on diverse codebases.","intents":["Extract code into separate functions or modules while preserving behavior","Rename variables and functions for improved readability","Restructure code to follow architectural patterns or coding standards","Simplify complex logic without changing functionality"],"best_for":["IDE plugins providing refactoring suggestions","Code review tools automating style and structure improvements","Automated code quality improvement pipelines","Teams standardizing code structure across large codebases"],"limitations":["Refactoring quality depends on code clarity; obfuscated or poorly structured code may be refactored incorrectly","No explicit verification that refactored code is semantically equivalent; requires test execution","Cannot refactor code with external dependencies or side effects that aren't visible in the code","May introduce subtle behavioral changes in edge cases or error handling paths","Limited to refactoring patterns seen during training; novel refactoring patterns may not generalize"],"requires":["Model trained on code with diverse refactoring patterns (both base and instruct models)","Clear specification of refactoring intent (e.g., 'extract this logic into a function')","Post-refactoring validation (compilation, type checking, test execution) to verify correctness"],"input_types":["code to be refactored","refactoring instruction (e.g., 'extract function', 'rename variable')","code + context (e.g., architectural patterns to follow)"],"output_types":["refactored code","explanation of changes","multiple refactoring variants"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"granite__cap_11","uri":"capability://code.generation.editing.context.aware.code.completion.with.multi.file.awareness","name":"context-aware code completion with multi-file awareness","description":"Generates contextually appropriate code completions by leveraging surrounding code context and, within context window limits, multi-file context to understand project structure and dependencies. The model uses attention mechanisms to identify relevant code patterns from the context window and generate completions that align with existing code style, naming conventions, and architectural patterns.","intents":["Complete code functions with awareness of project conventions and existing code patterns","Suggest API calls and library usage consistent with project dependencies","Generate code that matches the style and structure of surrounding code","Complete code with awareness of type signatures and function signatures from other files"],"best_for":["IDE integrations providing real-time code completion","Developers working in large codebases with consistent conventions","Teams with strong architectural patterns and coding standards","Projects with complex interdependencies requiring cross-file awareness"],"limitations":["Context window limits restrict multi-file awareness; large projects may exceed context capacity","No explicit project structure understanding; relies on code patterns visible in context window","Completion quality degrades when context is insufficient or ambiguous","No awareness of external dependencies or library APIs beyond what's visible in context","Attention mechanisms may focus on irrelevant context, generating completions that don't fit intent"],"requires":["Model with sufficient context window (4K-8K tokens recommended for multi-file awareness)","IDE integration or code editor plugin to provide surrounding code context","Inference framework supporting efficient context processing"],"input_types":["partial code with cursor position","surrounding code context (same file)","related code from other files (within context window)"],"output_types":["code completion suggestions","multiple completion variants","completion with confidence scores"],"categories":["code-generation-editing","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"granite__cap_2","uri":"capability://data.processing.analysis.enterprise.grade.code.data.curation.with.pii.redaction.and.malware.scanning","name":"enterprise-grade code data curation with pii redaction and malware scanning","description":"Implements a multi-stage data processing pipeline that filters, deduplicates, and sanitizes code training data through exact and fuzzy deduplication, PII redaction (replacing sensitive information with tokens), ClamAV malware scanning, and content filtering to reduce harmful code generation. This pipeline ensures training data complies with enterprise security and compliance requirements while maintaining code quality and diversity.","intents":["Train models on code data without exposing sensitive credentials, API keys, or personal information","Ensure generated code doesn't reproduce malicious patterns from training data","Meet compliance requirements (GDPR, HIPAA, SOC 2) for code generation in regulated industries","Reduce legal and security risks from training on unvetted open-source code"],"best_for":["Financial services and healthcare organizations with strict data governance requirements","Enterprises deploying code generation models in production with compliance obligations","Teams building internal code generation systems that must not leak sensitive information"],"limitations":["PII redaction is token-based and may miss context-specific sensitive information (e.g., internal domain names, project identifiers)","Malware scanning relies on ClamAV signatures; zero-day or obfuscated malware may not be detected","Fuzzy deduplication thresholds are fixed; may over-deduplicate similar-but-distinct code patterns or under-deduplicate near-duplicates","Data curation pipeline adds significant preprocessing overhead; not suitable for real-time data ingestion"],"requires":["ClamAV malware scanning engine installed and updated","PII redaction rules and token mapping configuration","Deduplication infrastructure (exact hash matching + fuzzy similarity computation)","Content filtering rules or classifiers for harmful code patterns"],"input_types":["raw code repositories or code files","GitHub issues and commit messages","public code datasets"],"output_types":["sanitized code training data","deduplication reports","PII redaction logs","malware detection alerts"],"categories":["data-processing-analysis","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"granite__cap_3","uri":"capability://code.generation.editing.scalable.multi.size.model.family.with.configurable.context.windows","name":"scalable multi-size model family with configurable context windows","description":"Provides four parameter-size variants (3B, 8B, 20B, 34B) each with configurable context windows (2K, 4K, 8K tokens), enabling deployment across diverse hardware constraints from edge devices to data centers. The model family uses a unified architecture with consistent tokenization and training methodology, allowing seamless model swapping without retraining or prompt engineering changes.","intents":["Deploy code generation on resource-constrained devices (edge, mobile, embedded systems)","Balance latency and quality by selecting appropriate model size for inference SLA","Run multiple model sizes in parallel for ensemble-based code generation","Scale from prototyping (small models) to production (larger models) without architectural changes"],"best_for":["Organizations with heterogeneous hardware infrastructure (GPUs, CPUs, edge devices)","Teams optimizing for latency-critical applications (IDE integrations, real-time chat)","Cost-conscious deployments where smaller models reduce inference compute spend","Research teams comparing model size vs. performance tradeoffs"],"limitations":["Smaller models (3B, 8B) have significantly lower code generation quality on complex tasks; not suitable for production without guardrails","Context window size directly impacts maximum code file size that can be processed; 2K tokens ≈ 500-800 lines of code","No dynamic model selection; developers must manually choose model size based on task complexity","Larger models (34B) require 80GB+ VRAM; quantization necessary for most deployments, introducing accuracy degradation"],"requires":["GPU with VRAM matching model size (3B: 8GB, 8B: 16GB, 20B: 40GB, 34B: 80GB minimum)","Quantization support (int8, int4, or similar) for models larger than available VRAM","Inference framework supporting multiple model sizes (vLLM, TensorRT-LLM, Ollama)","Benchmarking infrastructure to measure latency/quality tradeoffs for chosen size"],"input_types":["code prompts of varying length","multi-file code context (up to context window limit)","natural language instructions"],"output_types":["code completions","code explanations","refactored code"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"granite__cap_4","uri":"capability://text.generation.language.code.explanation.and.documentation.generation","name":"code explanation and documentation generation","description":"Generates natural language explanations of code functionality, purpose, and behavior by leveraging the model's understanding of code semantics learned during Phase 2 training (80% code + 20% language mixture). The model can produce docstrings, comments, and high-level summaries by conditioning on code input and generating corresponding natural language output.","intents":["Auto-generate docstrings and function documentation from code","Explain complex code logic in plain English for knowledge transfer","Create README sections and API documentation from code","Generate code comments explaining non-obvious implementation details"],"best_for":["Teams improving code documentation coverage without manual effort","Open-source projects needing automated documentation generation","Knowledge transfer scenarios where code needs explanation for new team members","Code review tools that need to explain code changes to reviewers"],"limitations":["Generated explanations may be generic or miss domain-specific context not evident from code alone","Explanation quality degrades on highly specialized or domain-specific code (e.g., numerical algorithms, DSL implementations)","No explicit validation that generated explanations are accurate; may contain hallucinations or misinterpretations","Limited to explanation length constrained by output token budget; cannot generate comprehensive documentation for large codebases"],"requires":["Model trained with code-to-language task during Phase 2 (both base and instruct models)","Inference framework supporting variable-length output generation","Post-processing to format generated explanations as docstrings or comments"],"input_types":["code function or method","code snippet with context","entire code file"],"output_types":["docstring in standard format (JSDoc, Python docstring, etc.)","inline code comments","natural language explanation","README section"],"categories":["text-generation-language","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"granite__cap_5","uri":"capability://code.generation.editing.bug.fixing.and.code.repair.via.semantic.understanding","name":"bug fixing and code repair via semantic understanding","description":"Identifies and fixes common code bugs by leveraging semantic understanding of code patterns learned during training on diverse codebases. The model can detect logical errors, missing error handling, type mismatches, and resource leaks by conditioning on buggy code and generating corrected versions, without explicit bug detection rules or static analysis.","intents":["Automatically fix common code bugs (null pointer dereferences, off-by-one errors, missing error handling)","Suggest corrections for code that fails type checking or linting","Repair code that violates security best practices (e.g., SQL injection, hardcoded credentials)","Generate fixed code from error messages or test failure descriptions"],"best_for":["IDE plugins that suggest bug fixes in real-time","Code review tools that identify and fix common issues automatically","CI/CD pipelines that auto-fix linting and type-checking failures","Educational platforms teaching debugging and code quality"],"limitations":["Bug fixing quality depends on bug prevalence in training data; rare or novel bugs may not be fixed correctly","No explicit reasoning about bug root causes; fixes may be superficial or incorrect for complex bugs","Cannot fix bugs requiring external context (e.g., API changes, library version incompatibilities)","May introduce new bugs while fixing existing ones if semantic understanding is incomplete","No verification that fixed code actually resolves the original bug; requires test execution for validation"],"requires":["Model trained on diverse code with natural bug patterns (both base and instruct models)","Optional: error messages or test failure descriptions to guide bug fixing","Post-generation validation (linting, type checking, test execution) to verify fixes"],"input_types":["buggy code snippet","code + error message","code + test failure description","code + linting violations"],"output_types":["corrected code","explanation of bug and fix","multiple fix suggestions"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"granite__cap_6","uri":"capability://code.generation.editing.code.translation.between.programming.languages","name":"code translation between programming languages","description":"Translates code from one programming language to another while preserving logic and intent by leveraging cross-language patterns learned during training on 116 languages. The model maps language-specific idioms, APIs, and syntax to equivalent constructs in the target language, enabling semantic-preserving code translation without explicit language-to-language mapping rules.","intents":["Migrate codebases from legacy languages (e.g., Cobol, Fortran) to modern languages (e.g., Python, Go)","Port code across different runtime environments (e.g., Java to C#, JavaScript to Python)","Create polyglot implementations of algorithms in multiple languages","Understand code logic by translating to a more familiar language"],"best_for":["Teams modernizing legacy codebases with language migrations","Organizations building cross-platform systems requiring code in multiple languages","Researchers studying code semantics across language boundaries","Educational contexts teaching language equivalence and design patterns"],"limitations":["Translation quality varies significantly by language pair; common pairs (Python↔JavaScript) perform better than rare pairs","Language-specific idioms and best practices may not translate; generated code may be idiomatic in source language but not target","Cannot translate code relying on language-specific libraries or runtime features without manual adaptation","Type system differences (e.g., Python dynamic vs. Java static) may require significant refactoring beyond translation","No validation that translated code is functionally equivalent; requires comprehensive testing"],"requires":["Model trained on 116 programming languages with sufficient examples of each language pair","Clear specification of source and target languages in prompt","Post-translation validation (compilation, type checking, test execution) to verify correctness"],"input_types":["code in source language","code + source/target language specification","code + library/framework context"],"output_types":["translated code in target language","translation notes explaining idiom changes","multiple translation variants"],"categories":["code-generation-editing","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"granite__cap_7","uri":"capability://code.generation.editing.fine.tuning.on.custom.code.datasets.and.domain.specific.patterns","name":"fine-tuning on custom code datasets and domain-specific patterns","description":"Supports fine-tuning of base models on custom code datasets to specialize the model for domain-specific code patterns, internal coding standards, or proprietary languages. The fine-tuning process leverages the pre-trained weights as initialization, enabling efficient adaptation to new domains with limited computational overhead compared to training from scratch.","intents":["Adapt Granite models to internal coding standards and architectural patterns","Specialize models for domain-specific languages (DSLs) or proprietary code","Improve performance on underrepresented languages or frameworks in the base model","Create organization-specific code generation models without training from scratch"],"best_for":["Enterprises with proprietary code patterns or internal DSLs","Organizations using niche programming languages or frameworks","Teams wanting to enforce specific coding standards through model fine-tuning","Research groups studying domain-specific code generation"],"limitations":["Fine-tuning requires significant computational resources (GPU clusters) and expertise; not suitable for small teams","Catastrophic forgetting risk: fine-tuning on narrow domains may degrade performance on general code tasks","Limited guidance on hyperparameters, dataset size, and training duration; requires experimentation","No built-in evaluation framework to measure fine-tuning effectiveness; requires custom benchmarking","Fine-tuned models may overfit to training data patterns, reducing generalization to novel code"],"requires":["Base model weights (3B, 8B, 20B, or 34B)","Custom code dataset (minimum 10K-100K examples depending on domain specificity)","Training infrastructure (GPU cluster with distributed training support)","Training framework supporting transformer fine-tuning (PyTorch, JAX, or similar)","Evaluation dataset to measure fine-tuning effectiveness"],"input_types":["custom code files or repositories","instruction-code pairs for supervised fine-tuning","code + metadata (e.g., code quality metrics, performance characteristics)"],"output_types":["fine-tuned model weights","fine-tuning metrics and loss curves","evaluation results on custom benchmarks"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"granite__cap_8","uri":"capability://automation.workflow.apache.2.0.licensed.open.source.deployment.without.vendor.lock.in","name":"apache 2.0 licensed open-source deployment without vendor lock-in","description":"Released under Apache 2.0 license with full model weights available for download, enabling unrestricted commercial and research use without API dependencies or vendor lock-in. Organizations can deploy models on-premises, in private clouds, or on any infrastructure without licensing restrictions or usage monitoring.","intents":["Deploy code generation models in air-gapped or regulated environments without cloud dependencies","Build proprietary code generation products without licensing fees or vendor restrictions","Maintain full control over model deployment, updates, and data privacy","Avoid vendor lock-in by using open-source models instead of proprietary APIs"],"best_for":["Financial services and healthcare organizations with strict data residency requirements","Governments and defense contractors requiring on-premises deployment","Startups building code generation products without licensing overhead","Organizations prioritizing data privacy and avoiding cloud dependencies"],"limitations":["Deployment and maintenance responsibility falls on the organization; no vendor support or SLAs","No automatic model updates; organizations must manually download and deploy new versions","Inference optimization and deployment infrastructure not provided; requires in-house expertise","No usage analytics or monitoring; organizations must build their own observability","Community support only; no guaranteed response times for issues or questions"],"requires":["Infrastructure to host and run models (on-premises servers, private cloud, or self-managed cloud instances)","Inference framework and deployment tooling (vLLM, TensorRT-LLM, Ollama, or similar)","DevOps expertise to manage model deployment, scaling, and updates","Monitoring and observability infrastructure for production deployments"],"input_types":["model weights (downloadable from Hugging Face or GitHub)","inference requests (code prompts, instructions)"],"output_types":["code generations","deployment metrics and logs"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"granite__cap_9","uri":"capability://safety.moderation.enterprise.ai.ethics.compliance.and.bias.mitigation","name":"enterprise ai ethics compliance and bias mitigation","description":"Developed according to IBM's AI Ethics principles with explicit focus on reducing harmful code generation, bias in recommendations, and ensuring responsible AI deployment. The training data curation pipeline includes content filtering to reduce harmful code patterns and PII redaction to prevent sensitive information leakage, embedding ethical considerations into the model architecture rather than as post-hoc guardrails.","intents":["Deploy code generation models in regulated industries with compliance requirements","Reduce risk of generating biased or harmful code patterns","Ensure code generation respects security and privacy best practices","Meet organizational AI ethics policies and governance requirements"],"best_for":["Financial services, healthcare, and government organizations with compliance obligations","Teams building AI systems with explicit ethics and fairness requirements","Organizations conducting AI audits or third-party risk assessments","Enterprises with AI governance frameworks requiring ethical AI certification"],"limitations":["Ethical considerations are embedded in training data curation, not in inference-time guardrails; cannot be adjusted post-deployment","No explicit bias measurement or fairness metrics; ethical compliance is implicit rather than measurable","Content filtering may be overly conservative, reducing model utility on legitimate but sensitive code patterns","No transparency into specific ethical design decisions or trade-offs made during training","Ethical compliance is relative to IBM's principles; may not align with all organizational ethics frameworks"],"requires":["Understanding of IBM's AI Ethics principles and how they apply to code generation","Organizational AI ethics policies to align with model design","Post-deployment monitoring to detect unintended harmful outputs"],"input_types":["code prompts and instructions","audit requests for ethical compliance"],"output_types":["code generations with reduced harmful patterns","compliance documentation","audit reports"],"categories":["safety-moderation","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"granite__headline","uri":"capability://code.generation.editing.enterprise.grade.code.generation.models","name":"enterprise-grade code generation models","description":"Granite Code Models are a family of open-source, enterprise-grade language models optimized for code generation and analysis across 116 programming languages, designed for both research and commercial use.","intents":["best code generation model","code generation models for enterprise applications","open-source models for code generation","multilingual code generation tools","AI models for legal analysis and code tasks"],"best_for":["enterprise applications","multilingual support"],"limitations":[],"requires":[],"input_types":[],"output_types":[],"categories":["code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":55,"verified":false,"data_access_risk":"high","permissions":["Model weights for chosen size variant (3B, 8B, 20B, or 34B parameters)","Inference framework supporting decoder-only transformer inference (vLLM, TensorRT-LLM, or similar)","GPU with sufficient VRAM (3B: 8GB, 8B: 16GB, 20B: 40GB, 34B: 80GB) or quantization support","Granite Code Instruct model variant (not base models)","Inference framework with instruction-following prompt templates","Understanding of effective prompt structure for code instructions","Model trained on code with diverse refactoring patterns (both base and instruct models)","Clear specification of refactoring intent (e.g., 'extract this logic into a function')","Post-refactoring validation (compilation, type checking, test execution) to verify correctness","Model with sufficient context window (4K-8K tokens recommended for multi-file awareness)"],"failure_modes":["Performance varies by language popularity in training data; less common languages (e.g., Cobol, Fortran) may have lower quality generations","No explicit language routing or language-specific prompting strategies built-in; requires manual prompt engineering to specify target language","Context window limited to 2K-8K tokens depending on model size, constraining multi-file code generation tasks","No real-time syntax validation; generated code may have subtle language-specific errors requiring post-generation linting","Instruction tuning may reduce raw code completion performance on non-instruction tasks compared to base models","Synthetic instruction datasets may contain biases or unrealistic code patterns that propagate to generations","No explicit instruction validation; model may misinterpret ambiguous or conflicting instructions","Limited to instruction types seen during tuning; novel instruction patterns may not generalize well","Refactoring quality depends on code clarity; obfuscated or poorly structured code may be refactored incorrectly","No explicit verification that refactored code is semantically equivalent; requires test execution","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.7,"quality":0.9,"ecosystem":0.39999999999999997,"match_graph":0.25,"freshness":0.52,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"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-06-17T09:51:04.691Z","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=granite","compare_url":"https://unfragile.ai/compare?artifact=granite"}},"signature":"LuUein/AwHOOjADZWMhwMuaJ36iOtlp8LQAhEa75hhkVpgsMucft5BazzhmtD+lXHUD+JKxgLK4muwkFTzxwCA==","signedAt":"2026-06-20T05:12:58.142Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/granite","artifact":"https://unfragile.ai/granite","verify":"https://unfragile.ai/api/v1/verify?slug=granite","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"}}