{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-salesforce--codet5","slug":"salesforce--codet5","name":"CodeT5","type":"model","url":"https://arxiv.org/abs/2305.07922","page_url":"https://unfragile.ai/salesforce--codet5","categories":["coding"],"tags":["code-generation","code-intelligence","code-understanding","language-model","large-language-models"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"inactive","verified":false},"capabilities":[{"id":"github-salesforce--codet5__cap_0","uri":"capability://code.generation.editing.encoder.decoder.code.generation.with.instruction.tuning","name":"encoder-decoder code generation with instruction tuning","description":"Generates code from natural language descriptions using a T5-based encoder-decoder architecture enhanced with instruction-tuning objectives. InstructCodeT5+ 16B variant processes natural language input through the encoder, then decodes syntactically valid code sequences using teacher-forced training with code-specific tokenization. The model achieves 36.1% Pass@1 on HumanEval by learning to follow structured programming instructions rather than pure next-token prediction.","intents":["I need to generate code from natural language specifications without manually writing boilerplate","I want a code generation model that understands programming instructions and context","I need to fine-tune a code generator on domain-specific programming tasks"],"best_for":["teams building code synthesis tools for specific domains","developers integrating instruction-following code generation into IDEs","researchers fine-tuning models on custom code datasets"],"limitations":["Requires 16B parameters for instruction-tuned variant — ~32GB VRAM for inference","Pass@1 accuracy of 36.1% means ~64% of single-attempt generations fail on HumanEval","No built-in multi-file context awareness — processes code generation per-function","Instruction tuning requires curated instruction-code pairs; zero-shot performance degrades on out-of-distribution tasks"],"requires":["Python 3.8+","PyTorch 1.9+ with CUDA support for GPU inference","Hugging Face transformers library 4.20+","16GB+ VRAM for 16B model inference, 8GB+ for smaller variants"],"input_types":["natural language text (function descriptions, docstrings)","code context (surrounding function signatures, imports)"],"output_types":["Python/Java/JavaScript/Go code sequences","token logits for beam search or sampling"],"categories":["code-generation-editing","language-models"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-salesforce--codet5__cap_1","uri":"capability://memory.knowledge.code.embedding.extraction.for.semantic.retrieval","name":"code embedding extraction for semantic retrieval","description":"Extracts dense vector embeddings from code snippets using a specialized 110M parameter embedding model that encodes semantic meaning of code into fixed-dimension vectors. The model processes code through a shared encoder and projects outputs to embedding space, enabling fast approximate nearest-neighbor search for code retrieval tasks. Achieves 74.23 average MRR across six programming languages by learning language-agnostic code semantics.","intents":["I need to find similar code snippets in a large codebase without full-text search","I want to build a semantic code search engine that understands intent, not just keywords","I need embeddings for downstream tasks like code clone detection or code recommendation"],"best_for":["teams building code search infrastructure for enterprise codebases","developers implementing code recommendation systems","researchers studying code similarity and clone detection"],"limitations":["110M embedding model has lower capacity than larger variants — may miss domain-specific code patterns","Embeddings are fixed-dimension (typically 768-1024D) — loses some fine-grained syntactic information","Requires pre-computing embeddings for entire codebase — not suitable for real-time code generation","MRR of 74.23 means ~25% of top-1 retrievals are incorrect; requires re-ranking for production use"],"requires":["Python 3.8+","PyTorch 1.9+ or TensorFlow 2.6+","Hugging Face transformers 4.20+","Vector database (Faiss, Pinecone, or Weaviate) for efficient similarity search","2GB+ VRAM for embedding model inference"],"input_types":["code snippets (functions, methods, classes)","code files (up to model's max token length ~512 tokens)"],"output_types":["dense vectors (768 or 1024 dimensions)","similarity scores for retrieval ranking"],"categories":["memory-knowledge","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-salesforce--codet5__cap_10","uri":"capability://code.generation.editing.multi.language.code.tokenization.with.unified.vocabulary","name":"multi-language code tokenization with unified vocabulary","description":"Tokenizes code from multiple programming languages (Python, Java, JavaScript, Go, Ruby, PHP, C++) using a unified vocabulary that captures language-agnostic code patterns. The tokenizer preserves code structure (indentation, brackets) while normalizing language-specific syntax, enabling a single model to process code across languages. Unified vocabulary reduces model size compared to language-specific tokenizers while maintaining code semantics.","intents":["I need to process code from multiple languages with a single model","I want to reduce model size by sharing vocabulary across languages","I need tokenization that preserves code structure and semantics"],"best_for":["teams building polyglot code analysis systems","researchers studying cross-lingual code understanding","organizations with multi-language codebases"],"limitations":["Unified vocabulary may be suboptimal for language-specific tokens — requires larger vocabulary than language-specific tokenizers","Tokenization assumes standard code formatting — may fail on obfuscated or non-standard code","No support for domain-specific languages (DSLs) or custom syntax — requires custom tokenizers","Token sequence length may be longer than language-specific tokenizers — increases inference latency"],"requires":["Python 3.8+","Hugging Face transformers 4.20+","Pre-trained tokenizer (available on Hugging Face Hub)","Code in supported languages (Python, Java, JavaScript, Go, Ruby, PHP, C++)"],"input_types":["code strings in supported languages","code files"],"output_types":["token IDs","token sequences","attention masks"],"categories":["code-generation-editing","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-salesforce--codet5__cap_11","uri":"capability://automation.workflow.configuration.driven.model.loading.and.inference","name":"configuration-driven model loading and inference","description":"Provides a configuration system that abstracts model loading, tokenization, and inference across different CodeT5+ variants (110M embedding, 220M bimodal, 770M general, 2B/6B/16B generation, InstructCodeT5+ 16B). Developers specify model variant and task in configuration files, and the framework automatically loads correct weights, tokenizer, and inference pipeline. Enables switching between models without code changes.","intents":["I need to easily switch between different CodeT5+ variants for experimentation","I want to configure model loading without writing boilerplate code","I need to deploy different models for different tasks in production"],"best_for":["teams managing multiple code models in production","researchers experimenting with different model variants","developers building model-agnostic code analysis pipelines"],"limitations":["Configuration system assumes standard model variants — custom models require manual configuration","No automatic model selection based on hardware constraints — requires manual variant choice","Configuration files may become complex for multi-model pipelines","Limited support for custom inference optimizations (quantization, pruning)"],"requires":["Python 3.8+","PyTorch 1.9+ or TensorFlow 2.6+","Hugging Face transformers 4.20+","Configuration files (YAML or JSON format)","Model weights (downloaded from Hugging Face Hub)"],"input_types":["configuration files (model variant, task, inference parameters)","code inputs (for inference)"],"output_types":["loaded model and tokenizer","inference results (code, embeddings, summaries)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-salesforce--codet5__cap_12","uri":"capability://search.retrieval.code.to.code.retrieval.for.clone.detection.and.similarity","name":"code-to-code retrieval for clone detection and similarity","description":"Retrieves similar code snippets from a codebase using code-to-code similarity computed via embedding vectors. The embedding model learns code semantics that capture functional similarity beyond syntactic matching, enabling detection of code clones with different variable names or control flow. Useful for identifying duplicate implementations, refactoring opportunities, and security vulnerabilities.","intents":["I need to find code clones in my codebase to identify refactoring opportunities","I want to detect similar code implementations across different files or projects","I need to identify potential security vulnerabilities by finding similar vulnerable code patterns"],"best_for":["teams managing large codebases with potential duplication","security teams identifying vulnerable code patterns","developers refactoring code to reduce duplication"],"limitations":["Embedding-based similarity may miss subtle differences in code behavior","Requires pre-computing embeddings for entire codebase — not suitable for real-time analysis","No support for semantic-level clone detection (e.g., different algorithms with same output)","Performance depends on embedding quality — may require fine-tuning for domain-specific code"],"requires":["Python 3.8+","CodeT5+ 110M embedding model","PyTorch 1.9+ with CUDA","Vector database (Faiss, Pinecone, Weaviate) for similarity search","Pre-computed embeddings for code corpus"],"input_types":["code snippets (query code)","code corpus (for similarity search)"],"output_types":["ranked list of similar code snippets","similarity scores","clone detection results"],"categories":["search-retrieval","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-salesforce--codet5__cap_2","uri":"capability://code.generation.editing.multi.language.code.summarization.via.bimodal.encoder.decoder","name":"multi-language code summarization via bimodal encoder-decoder","description":"Summarizes code into natural language descriptions using a 220M bimodal encoder-decoder that jointly processes code and text representations. The encoder learns unified representations of code syntax and semantics, while the decoder generates abstractive summaries in natural language. Bimodal training on code-summary pairs enables the model to capture both structural and semantic aspects of code without language-specific tokenizers.","intents":["I need to automatically generate docstrings for existing code without manual documentation","I want to understand what a code snippet does by reading a generated summary","I need to summarize code changes in pull requests for commit messages"],"best_for":["teams automating code documentation generation","developers building IDE plugins for code understanding","organizations maintaining large legacy codebases with missing documentation"],"limitations":["Bimodal training requires balanced code-summary datasets — performance degrades on code without natural language pairs","220M parameters limits context window — cannot summarize files >512 tokens","Abstractive summaries may hallucinate functionality not present in code","No support for code-specific documentation formats (e.g., Javadoc, JSDoc) — generates generic descriptions"],"requires":["Python 3.8+","PyTorch 1.9+ with CUDA for GPU acceleration","Hugging Face transformers 4.20+","4GB+ VRAM for inference","Code-summary training pairs if fine-tuning on domain-specific code"],"input_types":["code snippets (functions, methods, classes)","code files (up to 512 tokens)"],"output_types":["natural language summaries (1-3 sentences)","beam search candidates for summary ranking"],"categories":["code-generation-editing","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-salesforce--codet5__cap_3","uri":"capability://code.generation.editing.multi.variant.model.selection.with.parameter.performance.tradeoff","name":"multi-variant model selection with parameter-performance tradeoff","description":"Provides a family of pre-trained models (110M embedding, 220M bimodal, 770M general, 2B/6B/16B generation, InstructCodeT5+ 16B) allowing developers to select variants based on latency-accuracy tradeoffs. Each variant is pre-trained on the same code corpus but optimized for different tasks and inference constraints. The architecture enables progressive scaling from lightweight embedding models (2GB VRAM) to large generation models (32GB VRAM) without retraining.","intents":["I need to choose a code model that fits my hardware constraints and latency requirements","I want to start with a small model and upgrade to larger variants as my system scales","I need different models for different tasks (retrieval vs generation) in the same pipeline"],"best_for":["teams with heterogeneous hardware (edge devices to data centers)","startups prototyping with limited compute before scaling","organizations running multiple code tasks with different latency budgets"],"limitations":["Smaller variants (110M-220M) have significantly lower accuracy — 15.5% Pass@1 for 770M vs 36.1% for InstructCodeT5+ 16B","No automatic model selection — developers must manually choose variants based on benchmarks","Variant-specific fine-tuning required for domain adaptation — cannot transfer weights between sizes","Inference latency scales non-linearly with model size — 16B model ~10-20x slower than 220M variant"],"requires":["Python 3.8+","PyTorch 1.9+ or TensorFlow 2.6+","Hugging Face transformers 4.20+","2GB VRAM minimum (110M embedding), 32GB VRAM for 16B models","Benchmarking framework to measure latency-accuracy tradeoffs for your use case"],"input_types":["code snippets","natural language descriptions","code context (imports, function signatures)"],"output_types":["code sequences","embeddings","summaries","retrieval rankings"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-salesforce--codet5__cap_4","uri":"capability://code.generation.editing.humaneval.benchmark.evaluation.with.pass.k.metrics","name":"humaneval benchmark evaluation with pass@k metrics","description":"Evaluates code generation models using the HumanEval benchmark, which tests functional correctness on 164 hand-written programming problems. The evaluation framework computes Pass@k metrics (Pass@1, Pass@10, Pass@100) by sampling k code completions and checking if any passes unit tests. CodeT5+ 16B achieves 30.9% Pass@1 and 76.7% Pass@100, demonstrating the gap between single-attempt and multi-sample generation.","intents":["I need to benchmark my code generation model against standard metrics for comparison","I want to understand the gap between single-attempt and multi-sample code generation","I need to evaluate if my fine-tuned model improves over baseline CodeT5+ variants"],"best_for":["researchers publishing code generation models","teams evaluating code generation quality before production deployment","developers comparing different model variants for their use case"],"limitations":["HumanEval contains only 164 problems — may not represent production code diversity","Evaluation requires executing generated code — security risk if running untrusted code","Pass@k metrics favor models with high variance — doesn't measure consistency or code quality beyond functional correctness","No evaluation of code efficiency, readability, or maintainability — only functional correctness"],"requires":["Python 3.8+","HumanEval dataset (provided in repository)","Code execution environment (Docker or sandboxed VM recommended)","PyTorch or TensorFlow for model inference","Timeout mechanism to prevent infinite loops in generated code"],"input_types":["code generation model (PyTorch or Hugging Face transformers)","HumanEval problem specifications (function signatures, docstrings)"],"output_types":["Pass@1, Pass@10, Pass@100 metrics","per-problem correctness results","execution logs and error traces"],"categories":["code-generation-editing","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-salesforce--codet5__cap_5","uri":"capability://code.generation.editing.codebleu.metric.computation.for.code.generation.quality","name":"codebleu metric computation for code generation quality","description":"Computes CodeBLEU scores to evaluate code generation quality by measuring n-gram overlap, syntax tree matching, and dataflow matching between generated and reference code. The metric combines BLEU-style token matching with code-specific structural features (AST nodes, variable dataflow) to capture both syntactic and semantic correctness. Provides more nuanced evaluation than BLEU alone by rewarding structurally similar code even with different variable names.","intents":["I need to evaluate code generation quality without executing generated code","I want to measure how close generated code is to reference implementations","I need a metric that captures code structure, not just token similarity"],"best_for":["teams evaluating code generation during development (faster than HumanEval)","researchers comparing model variants without execution overhead","developers fine-tuning models on custom code datasets"],"limitations":["CodeBLEU correlates only ~0.6 with functional correctness — high CodeBLEU doesn't guarantee correct code","Requires reference code for comparison — cannot evaluate on novel problems without ground truth","AST parsing fails on syntactically invalid code — generated code with syntax errors scores 0","Language-specific — requires separate AST parsers for each programming language"],"requires":["Python 3.8+","CodeBLEU implementation (provided in repository)","Language-specific AST parsers (tree-sitter or language-native parsers)","Reference code dataset for comparison","Generated code outputs from model"],"input_types":["generated code sequences","reference code sequences","programming language identifier"],"output_types":["CodeBLEU score (0-100)","component scores (token match, syntax match, dataflow match)","per-sample evaluation results"],"categories":["code-generation-editing","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-salesforce--codet5__cap_6","uri":"capability://search.retrieval.text.to.code.retrieval.with.cross.lingual.matching","name":"text-to-code retrieval with cross-lingual matching","description":"Retrieves code snippets matching natural language queries by computing similarity between query embeddings and code embeddings across six programming languages. The 220M matching variant uses a bimodal encoder to align text and code representations in shared embedding space, enabling zero-shot retrieval across languages without language-specific fine-tuning. Achieves 75.85 average MRR by learning language-agnostic code semantics.","intents":["I need to find code examples matching a natural language description","I want to search a multi-language codebase with a single query","I need to build a code recommendation system that understands intent, not syntax"],"best_for":["teams building code search for polyglot codebases","developers implementing code example recommendation in IDEs","organizations with code repositories spanning multiple languages"],"limitations":["Cross-lingual matching requires balanced training data — performance degrades on underrepresented languages","MRR of 75.85 means ~24% of top-1 retrievals are incorrect — requires re-ranking or human review","Query understanding limited to natural language descriptions — cannot handle code-to-code queries","No semantic understanding of domain-specific terminology — requires domain-specific fine-tuning"],"requires":["Python 3.8+","CodeT5+ 220M matching model","PyTorch 1.9+ with CUDA for GPU inference","Vector database (Faiss, Pinecone, Weaviate) for efficient similarity search","Pre-computed embeddings for entire code corpus (4GB+ for large codebases)","4GB+ VRAM for embedding model inference"],"input_types":["natural language queries (function descriptions, intent statements)","code snippets (for embedding computation)"],"output_types":["ranked list of code snippets","similarity scores for each result","metadata (file path, language, function signature)"],"categories":["search-retrieval","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-salesforce--codet5__cap_7","uri":"capability://code.generation.editing.fine.tuning.framework.with.task.specific.adaptation","name":"fine-tuning framework with task-specific adaptation","description":"Provides a configurable fine-tuning pipeline that adapts pre-trained CodeT5+ models to downstream tasks (code generation, summarization, retrieval) using task-specific loss functions and data formats. The framework handles data loading, tokenization, training loop management, and evaluation, supporting both supervised fine-tuning and instruction-tuning objectives. Enables developers to customize training without reimplementing the full training loop.","intents":["I need to adapt CodeT5+ to my domain-specific code generation task","I want to fine-tune the model on proprietary code without sharing data with Salesforce","I need to quickly experiment with different fine-tuning strategies"],"best_for":["teams with domain-specific code datasets (financial systems, embedded code, DSLs)","researchers experimenting with fine-tuning strategies","organizations with privacy constraints preventing cloud-based model training"],"limitations":["Fine-tuning requires 16GB+ VRAM for 16B models — expensive for large-scale experimentation","Framework assumes standard code-task pairs — requires custom data loaders for non-standard formats","No automatic hyperparameter tuning — requires manual experimentation with learning rates, batch sizes","Fine-tuning on small datasets (<1000 examples) risks overfitting — requires careful regularization"],"requires":["Python 3.8+","PyTorch 1.9+ with CUDA support","Hugging Face transformers 4.20+","8GB+ VRAM minimum (16GB+ recommended for 16B models)","Structured training data (code-task pairs in JSON or CSV format)","Evaluation dataset for validation"],"input_types":["training data (code-task pairs)","validation data (for early stopping)","configuration files (learning rate, batch size, epochs)"],"output_types":["fine-tuned model weights","training logs (loss, validation metrics)","evaluation results on downstream task"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-salesforce--codet5__cap_8","uri":"capability://code.generation.editing.instruction.tuning.for.natural.language.guided.code.generation","name":"instruction-tuning for natural language-guided code generation","description":"Trains models to follow natural language instructions for code generation using instruction-tuning objectives that pair code with structured instructions (e.g., 'Generate a function that sorts an array'). InstructCodeT5+ 16B learns to parse instructions, decompose them into subtasks, and generate corresponding code. The approach achieves 36.1% Pass@1 on HumanEval by optimizing for instruction-following rather than raw next-token prediction.","intents":["I need a code model that understands and follows detailed programming instructions","I want to generate code from high-level specifications without providing code examples","I need to fine-tune a model on instruction-code pairs for my domain"],"best_for":["teams building code generation systems that accept natural language specifications","researchers studying instruction-following in code models","organizations with instruction-annotated code datasets"],"limitations":["Instruction-tuning requires high-quality instruction-code pairs — expensive to create at scale","Model performance degrades on instructions outside training distribution","36.1% Pass@1 accuracy means majority of single-attempt generations still fail","No built-in multi-turn instruction refinement — cannot iteratively improve generated code based on feedback"],"requires":["Python 3.8+","PyTorch 1.9+ with CUDA","Hugging Face transformers 4.20+","16GB+ VRAM for InstructCodeT5+ 16B inference","Instruction-code training pairs (can use existing datasets like APPS, CodeSearchNet)"],"input_types":["natural language instructions (function descriptions, requirements)","code context (imports, function signatures)"],"output_types":["code sequences","token logits for beam search"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-salesforce--codet5__cap_9","uri":"capability://code.generation.editing.pre.trained.encoder.decoder.with.masked.span.prediction","name":"pre-trained encoder-decoder with masked span prediction","description":"Pre-trains CodeT5 models using masked span prediction (similar to BERT) combined with next-token prediction objectives on large code corpora. The encoder learns bidirectional code representations by predicting masked token spans, while the decoder learns to generate code autoregressively. This dual-objective pre-training enables the model to understand code structure (encoder) and generate code sequences (decoder) without task-specific supervision.","intents":["I need a pre-trained code model that understands both code understanding and generation","I want to leverage pre-trained representations for downstream code tasks","I need a model trained on diverse code without task-specific annotations"],"best_for":["researchers studying code representation learning","teams building code understanding systems that require both encoding and generation","organizations fine-tuning on downstream tasks with limited labeled data"],"limitations":["Pre-training on large code corpus is computationally expensive — not practical to retrain from scratch","Masked span prediction objective may not align with downstream task objectives","No explicit code structure awareness (AST, dataflow) — learns structure implicitly from tokens","Performance on downstream tasks depends heavily on fine-tuning data quality and quantity"],"requires":["Python 3.8+","PyTorch 1.9+ or TensorFlow 2.6+","Hugging Face transformers 4.20+","Pre-trained model weights (available on Hugging Face Hub)","Downstream task data for fine-tuning"],"input_types":["code sequences (for encoder)","code context (for decoder)"],"output_types":["encoder hidden states (for code understanding tasks)","decoder outputs (for code generation tasks)"],"categories":["code-generation-editing","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":29,"verified":false,"data_access_risk":"high","permissions":["Python 3.8+","PyTorch 1.9+ with CUDA support for GPU inference","Hugging Face transformers library 4.20+","16GB+ VRAM for 16B model inference, 8GB+ for smaller variants","PyTorch 1.9+ or TensorFlow 2.6+","Hugging Face transformers 4.20+","Vector database (Faiss, Pinecone, or Weaviate) for efficient similarity search","2GB+ VRAM for embedding model inference","Pre-trained tokenizer (available on Hugging Face Hub)","Code in supported languages (Python, Java, JavaScript, Go, Ruby, PHP, C++)"],"failure_modes":["Requires 16B parameters for instruction-tuned variant — ~32GB VRAM for inference","Pass@1 accuracy of 36.1% means ~64% of single-attempt generations fail on HumanEval","No built-in multi-file context awareness — processes code generation per-function","Instruction tuning requires curated instruction-code pairs; zero-shot performance degrades on out-of-distribution tasks","110M embedding model has lower capacity than larger variants — may miss domain-specific code patterns","Embeddings are fixed-dimension (typically 768-1024D) — loses some fine-grained syntactic information","Requires pre-computing embeddings for entire codebase — not suitable for real-time code generation","MRR of 74.23 means ~25% of top-1 retrievals are incorrect; requires re-ranking for production use","Unified vocabulary may be suboptimal for language-specific tokens — requires larger vocabulary than language-specific tokenizers","Tokenization assumes standard code formatting — may fail on obfuscated or non-standard code","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.28964012907944103,"quality":0.25,"ecosystem":0.55,"match_graph":0.25,"freshness":0.27,"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":"inactive","updated_at":"2026-05-06T15:12:23.810Z","last_scraped_at":"2026-05-03T13:58:37.060Z","last_commit":"2024-01-20T11:34:30Z"},"community":{"stars":3101,"forks":493,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=salesforce--codet5","compare_url":"https://unfragile.ai/compare?artifact=salesforce--codet5"}},"signature":"h4laGSMqLozBRWjNFVH4rVN5bysvi3269TkaxUlyFwaVRzBEgBNUICxR0gnyiauZaSQe6LVMN43AjyRR/kH6Ag==","signedAt":"2026-06-22T16:23:58.624Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/salesforce--codet5","artifact":"https://unfragile.ai/salesforce--codet5","verify":"https://unfragile.ai/api/v1/verify?slug=salesforce--codet5","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"}}