{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"awesome-codefuse-devops-eval","slug":"codefuse-devops-eval","name":"Codefuse DevOps Eval","type":"repo","url":"https://github.com/codefuse-ai/codefuse-devops-eval","page_url":"https://unfragile.ai/codefuse-devops-eval","categories":["testing-quality","observability"],"tags":[],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"awesome-codefuse-devops-eval__cap_0","uri":"capability://data.processing.analysis.devops.domain.specific.model.evaluation.with.standardized.benchmarks","name":"devops domain-specific model evaluation with standardized benchmarks","description":"Evaluates foundation models against 7,486 multiple-choice questions spanning 8 DevOps lifecycle categories (Plan, Code, Build, Test, Release, Deploy, Operate, Monitor) using a three-component architecture: Core Evaluation System orchestrating the pipeline, curated Datasets with dev/test splits for zero-shot and few-shot scenarios, and Evaluation Scripts that load models, build contexts, and calculate metrics. The framework uses configuration files to determine which models and datasets participate in evaluation runs, enabling systematic comparison of model performance across DevOps knowledge domains.","intents":["Compare how different LLMs perform on DevOps-specific knowledge tasks","Track model improvement over time on standardized DevOps benchmarks","Identify which DevOps categories (e.g., Deploy vs Monitor) are model weaknesses","Evaluate models in zero-shot and few-shot learning configurations"],"best_for":["ML researchers benchmarking foundation models for DevOps applications","DevOps tool vendors evaluating LLM capabilities for automation","Teams building LLM-powered DevOps agents who need baseline performance metrics"],"limitations":["Multiple-choice format limits evaluation to recognition tasks, not generation quality","7,486 questions may not cover emerging DevOps practices (e.g., GitOps, eBPF observability)","Evaluation results are snapshot-based; no continuous tracking infrastructure included","No built-in statistical significance testing or confidence intervals for result comparison"],"requires":["Python 3.8+","PyTorch or TensorFlow for model inference","Hugging Face transformers library for model loading","4GB+ GPU memory for efficient model evaluation"],"input_types":["model identifiers (HuggingFace model names or local paths)","dataset selection configuration (JSON)","few-shot exemplars (text)"],"output_types":["accuracy metrics per DevOps category","per-sample predictions with confidence scores","aggregated performance reports (JSON/CSV)"],"categories":["data-processing-analysis","evaluation-benchmarking"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-codefuse-devops-eval__cap_1","uri":"capability://data.processing.analysis.aiops.scenario.evaluation.with.log.parsing.and.anomaly.detection.tasks","name":"aiops scenario evaluation with log parsing and anomaly detection tasks","description":"Evaluates models on 2,840 AIOps-specific samples covering log parsing, time series anomaly detection, root cause analysis, time series classification, and time series forecasting. The framework structures these tasks to test model capabilities in operational intelligence scenarios, with separate evaluation metrics tailored to each AIOps task type. Samples are organized into dev and test splits, allowing models to be evaluated in few-shot contexts where exemplars from the dev split inform predictions on test samples.","intents":["Assess LLM ability to parse and extract structured data from unstructured logs","Evaluate models on detecting anomalies in time series operational metrics","Test root cause analysis reasoning on real-world incident scenarios","Benchmark time series forecasting and classification on operational data"],"best_for":["AIOps platform developers evaluating LLM integration for intelligent alerting","SRE teams assessing whether LLMs can augment incident response workflows","Observability vendors benchmarking AI-powered log analysis capabilities"],"limitations":["2,840 samples may be insufficient for robust statistical conclusions on rare anomaly types","Time series tasks use fixed-length windows; may not capture long-range dependencies in real operational data","No evaluation of model performance under distribution shift (e.g., new log formats, metric drift)","Metrics are task-specific; no unified scoring across heterogeneous AIOps tasks"],"requires":["Python 3.8+","NumPy/Pandas for time series processing","Models must support structured output parsing (JSON or delimited formats)"],"input_types":["raw log text (unstructured strings)","time series data (numeric sequences with timestamps)","incident context (structured metadata about operational events)"],"output_types":["parsed log fields (structured JSON)","anomaly detection predictions (binary or confidence scores)","root cause classifications (categorical labels)","time series forecasts (numeric sequences)"],"categories":["data-processing-analysis","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-codefuse-devops-eval__cap_10","uri":"capability://data.processing.analysis.data.preprocessing.api.for.dataset.transformation.and.normalization","name":"data preprocessing api for dataset transformation and normalization","description":"Provides data preprocessing utilities to transform raw evaluation data into the framework's expected format (dev/test splits with category metadata, proper field naming, token count calculation). The preprocessing API includes functions for parsing raw datasets, normalizing field names, splitting into dev/test, assigning category labels, and calculating statistics. Users can apply preprocessing to custom datasets before integrating them into the framework, ensuring consistency with existing datasets.","intents":["Transform raw DevOps question datasets into framework format (dev/test splits, category labels)","Normalize field names and data types across heterogeneous dataset sources","Calculate dataset statistics (sample count, category distribution, token length distribution)","Validate datasets for consistency before integration into evaluation pipeline"],"best_for":["Teams integrating custom DevOps datasets into the evaluation framework","Researchers preparing datasets for benchmarking","Building data pipelines that feed into the evaluation framework"],"limitations":["Preprocessing API is limited to basic transformations; complex data cleaning requires custom code","No automatic category assignment; users must manually label samples or provide mapping","No handling of data quality issues (e.g., duplicates, malformed samples); users must clean data first","Preprocessing is one-time operation; no incremental updates to datasets"],"requires":["Python 3.8+","Pandas for data manipulation","Raw dataset in JSON or CSV format"],"input_types":["raw dataset (JSON/CSV with question, answer, and optional metadata)","category mapping (dict mapping samples to categories)","split ratio (proportion for dev/test split)"],"output_types":["preprocessed dataset (JSON with dev/test splits, normalized fields, category labels)","dataset statistics (sample count, category distribution, token length stats)","validation report (data quality issues, missing fields, etc.)"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-codefuse-devops-eval__cap_2","uri":"capability://tool.use.integration.tool.learning.evaluation.with.function.calling.across.239.tool.categories","name":"tool learning evaluation with function calling across 239 tool categories","description":"Evaluates models on 1,509 Tool Learning samples spanning 59 fields and 239 tool categories, assessing the model's ability to invoke functions and tools correctly. The framework implements specialized evaluation metrics for tool learning that measure whether models select the correct tool, format arguments properly, and chain multiple tool calls in sequence. Tool learning evaluation is integrated into the pipeline with dedicated data format specifications and metric calculations that differ from standard accuracy metrics.","intents":["Measure LLM capability to select and invoke the correct tool from a large catalog","Evaluate function argument formatting and parameter binding accuracy","Test multi-step tool chaining and sequential decision-making","Compare models on their ability to use domain-specific tool sets (e.g., Kubernetes tools, monitoring APIs)"],"best_for":["Teams building LLM agents that orchestrate DevOps tools and APIs","Tool vendors evaluating whether LLMs can reliably invoke their APIs","Researchers studying function calling capabilities in foundation models"],"limitations":["1,509 samples across 239 categories means sparse coverage per tool type; some tools may have <5 evaluation examples","Evaluation assumes tool schemas are static; doesn't test model adaptation to schema changes or new tools","No evaluation of error recovery (e.g., handling tool failures and retrying with different parameters)","Tool learning metrics are custom; no standardized comparison with other function-calling benchmarks"],"requires":["Python 3.8+","Tool schema definitions (JSON schema format)","Models must support structured output or function calling APIs (OpenAI format, Anthropic tools, etc.)"],"input_types":["tool schema catalog (JSON schema definitions for 239 tools)","natural language task descriptions","few-shot exemplars showing correct tool invocations"],"output_types":["tool selection predictions (categorical: which tool to invoke)","argument binding predictions (structured: parameter name-value pairs)","tool call sequences (ordered list of function invocations)","tool learning metrics (accuracy, F1, per-tool performance)"],"categories":["tool-use-integration","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-codefuse-devops-eval__cap_3","uri":"capability://tool.use.integration.flexible.model.loader.with.support.for.hugging.face.and.custom.implementations","name":"flexible model loader with support for hugging face and custom implementations","description":"Implements a ModelAndTokenizerLoader base class that provides default implementations for loading models and tokenizers from Hugging Face, with extensibility hooks for custom model architectures. Models are registered in model_conf.json, which maps model identifiers to their loader implementations and configuration parameters. The system allows users to override default loading behavior for specialized models (e.g., quantized models, custom fine-tuned variants) by implementing custom loader subclasses that inherit from ModelAndTokenizerLoader.","intents":["Load standard Hugging Face models without custom code","Integrate custom or proprietary model implementations into the evaluation framework","Support quantized or optimized model variants (e.g., GGUF, AWQ) with specialized loaders","Configure model-specific parameters (e.g., device placement, precision, batch size) via JSON"],"best_for":["Researchers evaluating diverse model architectures (open-source and custom)","Teams with proprietary models who need to integrate them into standardized evaluation","DevOps teams running evaluations on resource-constrained infrastructure (quantized models)"],"limitations":["Loader abstraction adds ~50-100ms overhead per model initialization","Custom loaders require Python implementation; no declarative configuration for complex loading logic","No built-in support for distributed model loading (e.g., multi-GPU sharding); users must implement custom loaders","Model configuration is static (model_conf.json); runtime model swapping requires framework restart"],"requires":["Python 3.8+","Hugging Face transformers library","PyTorch or TensorFlow (depending on model backend)","model_conf.json with model registration entries"],"input_types":["model identifier (string: HuggingFace model name or local path)","model configuration (JSON: loader class, parameters, device settings)","optional: custom loader implementation (Python class)"],"output_types":["loaded model object (transformers.PreTrainedModel or custom)","tokenizer object (transformers.PreTrainedTokenizer)","model metadata (context length, vocabulary size, etc.)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-codefuse-devops-eval__cap_4","uri":"capability://text.generation.language.context.building.system.with.model.specific.input.formatting","name":"context building system with model-specific input formatting","description":"Implements a ContextBuilder abstraction that formats evaluation inputs (questions, few-shot exemplars, tool schemas) into model-specific prompt formats. Different models require different context structures (e.g., chat templates, instruction formats, tool-calling schemas), so the framework allows registering custom ContextBuilder implementations per model. The context builder receives raw evaluation data and produces formatted strings or structured inputs that the model's inference engine expects, enabling consistent evaluation across models with heterogeneous input requirements.","intents":["Format DevOps questions and answers into model-specific prompt templates","Construct few-shot exemplars with proper formatting for each model's expected input structure","Build tool-calling contexts with schema definitions in the format each model expects","Handle model-specific special tokens and formatting conventions (e.g., chat templates, instruction markers)"],"best_for":["Evaluating models with diverse prompt format requirements (chat vs instruction vs raw)","Ensuring fair comparison by using each model's optimal input format","Extending evaluation to new models with custom prompt requirements"],"limitations":["Context builders are model-specific; adding a new model requires implementing a new ContextBuilder","No automatic prompt optimization; builders use fixed templates that may not be optimal for all models","Context length is not dynamically managed; builders may produce contexts exceeding model's max token limit","No built-in prompt injection detection or sanitization in context building"],"requires":["Python 3.8+","Model-specific prompt format documentation","Custom ContextBuilder implementation per model variant"],"input_types":["raw evaluation question (text string)","few-shot exemplars (list of question-answer pairs)","tool schemas (JSON schema definitions)","model configuration (specifying which ContextBuilder to use)"],"output_types":["formatted prompt string (ready for model inference)","structured input dict (for models expecting JSON-formatted inputs)","token count estimate (for context length validation)"],"categories":["text-generation-language","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-codefuse-devops-eval__cap_5","uri":"capability://planning.reasoning.zero.shot.and.few.shot.evaluation.configuration.with.exemplar.selection","name":"zero-shot and few-shot evaluation configuration with exemplar selection","description":"Supports both zero-shot evaluation (no exemplars) and few-shot evaluation (with exemplars from dev split) through configuration-driven pipeline control. The framework organizes datasets into dev and test splits, where dev split contains exemplars that can be included in prompts for few-shot scenarios. The evaluation pipeline reads configuration files that specify the evaluation mode, number of exemplars, and exemplar selection strategy, then constructs contexts accordingly and measures model performance under each condition.","intents":["Compare model performance in zero-shot vs few-shot scenarios to measure in-context learning ability","Evaluate models with varying numbers of exemplars (1-shot, 3-shot, 5-shot, etc.) to understand learning curves","Assess whether few-shot exemplars improve performance on specific DevOps categories","Measure model robustness by evaluating on the same task with different exemplar selections"],"best_for":["Researchers studying in-context learning capabilities of foundation models","Teams evaluating whether few-shot prompting is necessary for their DevOps use case","Comparing models on their ability to learn from examples vs relying on pre-training knowledge"],"limitations":["Exemplar selection is static (from dev split); no dynamic exemplar selection based on test sample similarity","No analysis of exemplar quality or diversity; assumes all dev samples are equally useful","Few-shot evaluation may exceed model context length for large exemplar sets; no automatic truncation","No measurement of exemplar order effects (e.g., does order of few-shot examples affect predictions?)"],"requires":["Python 3.8+","Dataset with dev/test splits","Configuration file specifying zero-shot or few-shot mode and exemplar count"],"input_types":["evaluation mode configuration (zero-shot or few-shot)","exemplar count (integer: number of examples to include)","dev split samples (for few-shot exemplars)","test split samples (for evaluation)"],"output_types":["zero-shot accuracy metrics","few-shot accuracy metrics (per exemplar count)","performance delta (few-shot vs zero-shot improvement)","per-category performance breakdown"],"categories":["planning-reasoning","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-codefuse-devops-eval__cap_6","uri":"capability://data.processing.analysis.dataset.organization.with.category.based.splits.and.metadata","name":"dataset organization with category-based splits and metadata","description":"Organizes evaluation data into three main dataset categories (DevOps General with 7,486 samples, AIOps with 2,840 samples, Tool Learning with 1,509 samples), each with dev/test splits and category-level metadata. Datasets are structured to enable filtering by DevOps lifecycle stage (Plan, Code, Build, Test, Release, Deploy, Operate, Monitor), AIOps task type (log parsing, anomaly detection, RCA, classification, forecasting), or tool category. The framework provides APIs to load datasets, filter by category, and access both raw samples and preprocessed versions.","intents":["Load specific evaluation datasets (DevOps, AIOps, or Tool Learning) without loading all data","Filter evaluation samples by category to analyze model performance on specific domains","Access dev split exemplars for few-shot evaluation","Analyze dataset statistics (sample count, category distribution, token length distribution)"],"best_for":["Researchers analyzing model performance on specific DevOps domains (e.g., Deploy vs Monitor)","Teams focusing evaluation on relevant AIOps tasks (e.g., only log parsing, not forecasting)","Building custom evaluation pipelines that need flexible dataset access"],"limitations":["Dataset organization is fixed; no dynamic dataset composition or custom category definitions","No built-in data versioning; dataset updates require manual version management","Category distribution is imbalanced (e.g., some DevOps categories may have fewer samples)","No metadata about data collection methodology, annotation guidelines, or inter-annotator agreement"],"requires":["Python 3.8+","Dataset files (JSON or CSV format)","Pandas for dataset manipulation"],"input_types":["dataset name (string: 'devops', 'aiops', or 'tool_learning')","optional: category filter (string or list of categories)","optional: split selection ('dev' or 'test')"],"output_types":["dataset samples (list of dicts with question, answer, category, etc.)","dataset statistics (count, category distribution, token length stats)","filtered subsets (samples matching category filter)"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-codefuse-devops-eval__cap_7","uri":"capability://data.processing.analysis.evaluation.metrics.calculation.with.category.level.and.task.specific.scoring","name":"evaluation metrics calculation with category-level and task-specific scoring","description":"Calculates evaluation metrics tailored to each dataset type: accuracy and per-category breakdown for DevOps General, task-specific metrics (precision/recall for anomaly detection, RMSE for forecasting, etc.) for AIOps, and tool-specific metrics (tool selection accuracy, argument binding accuracy, chaining accuracy) for Tool Learning. The framework aggregates metrics at multiple levels (overall, per-category, per-task) and produces detailed reports showing model performance across different dimensions. Metrics are calculated using standard ML evaluation libraries (scikit-learn) with custom aggregation logic for domain-specific metrics.","intents":["Calculate overall accuracy and per-category performance for DevOps knowledge evaluation","Compute task-specific metrics for AIOps (anomaly detection precision/recall, forecasting RMSE, etc.)","Measure tool learning performance (tool selection accuracy, argument binding accuracy, chaining success)","Generate detailed performance reports for model comparison and analysis"],"best_for":["Researchers analyzing model performance across multiple evaluation dimensions","Teams comparing models and needing detailed breakdowns by category/task","Building dashboards or reports that visualize model performance"],"limitations":["Metrics are task-specific; no unified scoring across heterogeneous tasks (DevOps + AIOps + Tool Learning)","No statistical significance testing or confidence intervals; results are point estimates","Metrics assume balanced class distribution; imbalanced categories may skew results","No built-in support for weighted metrics (e.g., weighting critical DevOps categories higher)"],"requires":["Python 3.8+","scikit-learn for metric calculation","NumPy/Pandas for aggregation"],"input_types":["model predictions (list of predicted labels or values)","ground truth labels (list of correct answers)","category assignments (mapping samples to categories)","task type (for selecting appropriate metrics)"],"output_types":["overall accuracy/F1/RMSE (depending on task)","per-category metrics (dict mapping category to metrics)","per-task metrics (for AIOps and Tool Learning)","detailed report (JSON or CSV with all metrics)"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-codefuse-devops-eval__cap_8","uri":"capability://tool.use.integration.extensible.framework.for.adding.custom.models.and.datasets","name":"extensible framework for adding custom models and datasets","description":"Provides extension points for integrating custom models and datasets into the evaluation pipeline through well-defined interfaces: custom models are added by implementing ModelAndTokenizerLoader and ContextBuilder subclasses and registering them in model_conf.json; custom datasets are added by implementing data preprocessing logic and organizing samples into the framework's expected format (dev/test splits with category metadata). The framework is designed to be modular, allowing users to extend it without modifying core evaluation code.","intents":["Integrate proprietary or fine-tuned models into the evaluation framework","Add custom DevOps datasets or domain-specific evaluation tasks","Extend evaluation to new model architectures or dataset types","Build custom evaluation pipelines on top of the framework"],"best_for":["Teams with proprietary models or datasets who want to use the evaluation framework","Researchers extending the framework with new evaluation tasks or model types","Organizations building custom DevOps evaluation suites"],"limitations":["Extension requires Python implementation; no low-code/no-code extension mechanism","Documentation for extension points may be incomplete; requires reading source code","No versioning or compatibility guarantees for extension interfaces across framework updates","Custom extensions are not automatically tested; users must validate their implementations"],"requires":["Python 3.8+","Understanding of framework architecture (ModelAndTokenizerLoader, ContextBuilder, dataset format)","Ability to implement custom Python classes"],"input_types":["custom model implementation (Python class inheriting from ModelAndTokenizerLoader)","custom context builder (Python class inheriting from ContextBuilder)","custom dataset (JSON/CSV with dev/test splits and category metadata)"],"output_types":["integrated model (registered in model_conf.json, usable in evaluation pipeline)","integrated dataset (loadable via dataset API, filterable by category)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-codefuse-devops-eval__cap_9","uri":"capability://automation.workflow.configuration.driven.evaluation.pipeline.orchestration","name":"configuration-driven evaluation pipeline orchestration","description":"Orchestrates the entire evaluation process through configuration files (JSON) that specify which models to evaluate, which datasets to use, evaluation mode (zero-shot/few-shot), and output format. The pipeline reads configuration, loads specified models and datasets, builds contexts, runs inference, calculates metrics, and generates reports—all without requiring code changes. Configuration files decouple evaluation logic from execution parameters, enabling reproducible evaluations and easy parameter sweeps (e.g., evaluating multiple models on multiple datasets).","intents":["Run evaluation experiments by modifying configuration files instead of code","Reproduce evaluation results by sharing configuration files","Perform parameter sweeps (e.g., evaluate 10 models on 3 datasets) with declarative configuration","Automate evaluation in CI/CD pipelines using configuration-driven execution"],"best_for":["Teams running repeated evaluation experiments with different model/dataset combinations","Researchers sharing reproducible evaluation configurations","CI/CD pipelines that need to run evaluations automatically"],"limitations":["Configuration schema is fixed; complex evaluation logic cannot be expressed in JSON","No built-in configuration validation; invalid configs fail at runtime","Configuration files are not versioned with results; hard to trace which config produced which results","No support for conditional logic or dynamic configuration (e.g., skip evaluation if model not available)"],"requires":["Python 3.8+","Configuration file (JSON format) with model, dataset, and evaluation parameters"],"input_types":["configuration file (JSON with model list, dataset list, evaluation mode, output format)","optional: command-line overrides for configuration parameters"],"output_types":["evaluation results (JSON/CSV with metrics)","detailed reports (per-model, per-dataset, per-category)","logs (execution trace for debugging)"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":29,"verified":false,"data_access_risk":"high","permissions":["Python 3.8+","PyTorch or TensorFlow for model inference","Hugging Face transformers library for model loading","4GB+ GPU memory for efficient model evaluation","NumPy/Pandas for time series processing","Models must support structured output parsing (JSON or delimited formats)","Pandas for data manipulation","Raw dataset in JSON or CSV format","Tool schema definitions (JSON schema format)","Models must support structured output or function calling APIs (OpenAI format, Anthropic tools, etc.)"],"failure_modes":["Multiple-choice format limits evaluation to recognition tasks, not generation quality","7,486 questions may not cover emerging DevOps practices (e.g., GitOps, eBPF observability)","Evaluation results are snapshot-based; no continuous tracking infrastructure included","No built-in statistical significance testing or confidence intervals for result comparison","2,840 samples may be insufficient for robust statistical conclusions on rare anomaly types","Time series tasks use fixed-length windows; may not capture long-range dependencies in real operational data","No evaluation of model performance under distribution shift (e.g., new log formats, metric drift)","Metrics are task-specific; no unified scoring across heterogeneous AIOps tasks","Preprocessing API is limited to basic transformations; complex data cleaning requires custom code","No automatic category assignment; users must manually label samples or provide mapping","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.47,"ecosystem":0.49999999999999994,"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:02.371Z","last_scraped_at":"2026-05-03T14:00:30.220Z","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=codefuse-devops-eval","compare_url":"https://unfragile.ai/compare?artifact=codefuse-devops-eval"}},"signature":"xPp5Iqcm4o5QpzbeVX1y+kUM4vHOF9EWGT/YB/DZ68PVqkbWAeuhz6baCdYawU3pb/r2+7Nfcrd1zKyHk6CXBg==","signedAt":"2026-07-09T04:19:25.871Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/codefuse-devops-eval","artifact":"https://unfragile.ai/codefuse-devops-eval","verify":"https://unfragile.ai/api/v1/verify?slug=codefuse-devops-eval","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"}}