{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-zai-org--codegeex","slug":"zai-org--codegeex","name":"CodeGeeX","type":"model","url":"https://codegeex.cn","page_url":"https://unfragile.ai/zai-org--codegeex","categories":["code-editors"],"tags":["code-generation","pretrained-models","tools"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-zai-org--codegeex__cap_0","uri":"capability://code.generation.editing.multilingual.code.generation.from.natural.language.and.partial.code","name":"multilingual code generation from natural language and partial code","description":"Generates executable code in Python, C++, Java, JavaScript, and Go using a 13B-parameter Transformer decoder with 40 layers trained on 850B+ tokens across 23 programming languages. The model uses a GPT-2 tokenizer extended with whitespace tokens (50,400 vocab) and processes up to 2,048 token sequences, enabling both zero-shot generation from natural language descriptions and continuation-based completion from partial code snippets. Inference supports single-GPU (27GB FP16), quantized (15GB 8-bit), and multi-GPU parallel deployment via checkpoint conversion and distributed inference scripts.","intents":["Generate complete functions or classes from English descriptions without writing boilerplate","Auto-complete code snippets in multiple languages with context-aware suggestions","Rapidly prototype algorithms in unfamiliar languages by describing intent in natural language","Generate test cases or utility functions for existing codebases"],"best_for":["polyglot development teams working across Python, C++, Java, JavaScript, Go","developers prototyping in multiple languages without deep expertise in each","teams building code generation pipelines that need open-source, self-hosted alternatives to cloud APIs"],"limitations":["Maximum sequence length of 2,048 tokens limits context for very large files or complex multi-file generation","Training data cutoff at June 2022 means no knowledge of recent language features or libraries","Single-GPU deployment requires >27GB VRAM; quantization to 15GB introduces precision loss affecting code quality","No built-in semantic validation — generated code may be syntactically correct but logically incorrect","Cross-language generation quality varies; performance strongest on Python, weaker on C++ and Go"],"requires":["Python 3.7+","PyTorch 1.9+ or OneFlow framework","GPU with 27GB VRAM (FP16) or 15GB (8-bit quantized)","Model checkpoint (13B parameters, ~26GB disk space)","CUDA 11.0+ for GPU acceleration"],"input_types":["natural language descriptions (English)","partial code snippets with cursor position","function signatures with docstrings","code comments describing intended behavior"],"output_types":["executable code in target language","multiple candidate completions (beam search)","token-level confidence scores"],"categories":["code-generation-editing","multilingual-models"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-zai-org--codegeex__cap_1","uri":"capability://code.generation.editing.cross.language.code.translation.with.semantic.preservation","name":"cross-language code translation with semantic preservation","description":"Translates code between Python, C++, Java, JavaScript, and Go by leveraging the multilingual Transformer decoder trained on parallel code examples across 23 languages. The model encodes source code as tokens and generates semantically equivalent target code by learning language-agnostic algorithmic patterns during training. Translation quality depends on the model's ability to abstract syntax and control flow across language boundaries; the 2,048 token limit constrains translation of large functions.","intents":["Convert legacy Python codebases to Go or C++ for performance-critical deployments","Translate JavaScript frontend logic to Python backend without manual rewriting","Port algorithms between languages while maintaining correctness and style","Generate reference implementations in multiple languages from a single source"],"best_for":["teams migrating between technology stacks (e.g., Python to Go microservices)","polyglot organizations needing quick reference implementations across languages","developers learning new languages by seeing idiomatic translations of familiar code"],"limitations":["No semantic validation — translated code may compile but not preserve original behavior","Language-specific idioms and performance patterns often lost in translation (e.g., Python list comprehensions → Java streams)","Requires source code fit within 2,048 tokens; large functions must be split manually","No awareness of language-specific libraries or APIs — may generate non-existent function calls","Type system mismatches (e.g., Python duck typing → Java static typing) require manual post-processing"],"requires":["Python 3.7+","PyTorch 1.9+ or OneFlow","GPU with 15GB+ VRAM (quantized) or 27GB (FP16)","Model checkpoint and tokenizer"],"input_types":["source code in Python, C++, Java, JavaScript, or Go","optional target language specification","function or class-level code segments"],"output_types":["translated code in target language","multiple candidate translations (beam search)","token-level confidence scores"],"categories":["code-generation-editing","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-zai-org--codegeex__cap_10","uri":"capability://automation.workflow.training.and.fine.tuning.pipeline.with.data.processing","name":"training and fine-tuning pipeline with data processing","description":"Provides end-to-end training infrastructure for fine-tuning CodeGeeX on custom datasets. The pipeline includes data processing scripts for tokenization and batching, training scripts supporting distributed training on Ascend 910 processors (or PyTorch equivalents), and checkpoint management for saving/resuming training. Training supports both full model fine-tuning and parameter-efficient approaches (e.g., LoRA, though not explicitly documented).","intents":["Fine-tune CodeGeeX on domain-specific code (e.g., Kubernetes manifests, Terraform, domain-specific languages)","Adapt CodeGeeX to organizational coding standards and patterns","Train custom code generation models starting from CodeGeeX checkpoints"],"best_for":["organizations with large proprietary codebases wanting to fine-tune CodeGeeX","researchers exploring code generation model improvements","teams building domain-specific code generation systems"],"limitations":["Training requires significant computational resources (original training used 1,536 Ascend 910 processors for ~2 months)","Fine-tuning on smaller datasets may lead to catastrophic forgetting of multilingual capabilities","No documented parameter-efficient fine-tuning (e.g., LoRA); full model fine-tuning is computationally expensive","Data processing pipeline assumes code-only datasets; no built-in support for code-comment pairs or other formats","No automated hyperparameter tuning; requires manual experimentation"],"requires":["Python 3.7+","PyTorch 1.9+ or OneFlow framework","Multiple GPUs (8+ recommended) or TPUs for distributed training","Training data in supported format (code files or tokenized datasets)","Significant computational budget (weeks to months for full training)"],"input_types":["raw code files in supported languages","tokenized datasets (pre-processed code)","training configuration (learning rate, batch size, epochs)"],"output_types":["fine-tuned model checkpoint","training logs and metrics","validation results"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-zai-org--codegeex__cap_11","uri":"capability://tool.use.integration.web.interface.for.interactive.code.generation.and.exploration","name":"web interface for interactive code generation and exploration","description":"Provides a web-based UI for interactive code generation, allowing users to input natural language descriptions or code snippets and receive generated code without installing IDE extensions or managing inference servers. The web interface communicates with a backend CodeGeeX inference server via HTTP API, supporting the same four interaction modes as the IDE extension (completion, comment-to-code, explanation, summarization).","intents":["Generate code without installing IDE extensions or managing local inference servers","Explore CodeGeeX capabilities through an interactive web interface","Share code generation examples and results with non-technical stakeholders"],"best_for":["developers wanting to try CodeGeeX without setup overhead","teams evaluating CodeGeeX for adoption","non-technical users exploring code generation capabilities"],"limitations":["Web interface requires backend inference server; no built-in server deployment","Inference latency visible to users; slow responses degrade user experience","No persistent session state; each request is independent","Limited context awareness compared to IDE integration (no file-level context)","No authentication or access control; requires external security layer for production"],"requires":["Web browser (modern Chrome, Firefox, Safari, Edge)","Backend CodeGeeX inference server (Python 3.7+, PyTorch 1.9+, GPU with 15GB+ VRAM)","Network connectivity to inference server"],"input_types":["natural language descriptions","code snippets","selected code for explanation/summarization"],"output_types":["generated code","explanations","summaries"],"categories":["tool-use-integration","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-zai-org--codegeex__cap_2","uri":"capability://code.generation.editing.ide.integrated.real.time.code.completion.with.multi.mode.interaction","name":"ide-integrated real-time code completion with multi-mode interaction","description":"Integrates with VS Code (via aminer.codegeex extension) and JetBrains IDEs (IntelliJ IDEA, PyCharm, GoLand, CLion) to provide real-time code completion, code explanation, and code summarization. The extension communicates with a local or remote CodeGeeX inference server via HTTP/gRPC, sending cursor context (surrounding code, file type, position) and receiving token-level completions. Four interaction modes support different workflows: inline completion (Copilot-style), comment-to-code generation, code explanation, and function summarization.","intents":["Get real-time code suggestions while typing without context switching to a web interface","Generate code from comments or docstrings directly in the editor","Understand unfamiliar code by requesting AI-generated explanations inline","Quickly document functions with auto-generated summaries"],"best_for":["individual developers using VS Code or JetBrains IDEs","teams deploying CodeGeeX on-premises for code completion without cloud API calls","organizations with strict data residency requirements (code never leaves the network)"],"limitations":["Inference latency depends on hardware; single-GPU inference adds 500ms-2s per completion on typical GPUs","Extension requires manual server setup and configuration; no one-click deployment","Context window limited to 2,048 tokens; large files may not provide sufficient context for accurate completions","No persistent memory across sessions — each completion is independent","IDE integration limited to VS Code and JetBrains; no support for Vim, Emacs, or other editors"],"requires":["VS Code 1.50+ or JetBrains IDE (IntelliJ IDEA 2020.1+, PyCharm 2020.1+, etc.)","CodeGeeX inference server running locally or on network (Python 3.7+, PyTorch 1.9+)","GPU with 15GB+ VRAM (quantized) or 27GB (FP16) for server","Network connectivity between IDE and inference server"],"input_types":["cursor position in editor","surrounding code context (lines before/after cursor)","file type/language","user-written comments or docstrings","selected code for explanation/summarization"],"output_types":["inline code completions (single or multiple candidates)","generated code from comments","natural language explanations","function/class summaries"],"categories":["code-generation-editing","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-zai-org--codegeex__cap_3","uri":"capability://code.generation.editing.quantized.model.deployment.with.memory.efficiency.tradeoffs","name":"quantized model deployment with memory-efficiency tradeoffs","description":"Reduces the 13B-parameter model from 27GB (FP16) to 15GB through 8-bit quantization, enabling deployment on mid-range GPUs. The quantization process uses scripts/test_inference_quantized.sh to load checkpoints with reduced precision, trading inference speed and code quality for memory efficiency. Quantized models maintain functional correctness for most code generation tasks but show measurable degradation in complex reasoning and multi-step logic.","intents":["Deploy CodeGeeX on GPUs with 15-16GB VRAM (e.g., RTX 3090, A10) instead of requiring 27GB","Run inference on cost-constrained hardware or edge devices with limited memory","Reduce memory footprint for multi-tenant inference servers handling concurrent requests"],"best_for":["teams with limited GPU budgets deploying on mid-range consumer or datacenter GPUs","edge deployment scenarios where model must fit on resource-constrained hardware","multi-tenant inference services needing to fit multiple models or requests in VRAM"],"limitations":["8-bit quantization introduces precision loss affecting code quality, particularly for complex algorithms and multi-step logic","Inference speed may be slower than FP16 on some hardware due to quantization overhead","No adaptive quantization — all layers quantized uniformly; no option to quantize only non-critical layers","Quantized checkpoints require separate storage and conversion; no dynamic quantization at runtime","Quality degradation not quantified in paper; requires empirical testing per use case"],"requires":["Python 3.7+","PyTorch 1.9+ with quantization support","GPU with 15GB+ VRAM","Quantized model checkpoint (generated via scripts/get_ckpt_qkv.py)","CUDA 11.0+ for GPU acceleration"],"input_types":["natural language descriptions","partial code snippets","function signatures"],"output_types":["executable code (lower quality than FP16)","multiple candidate completions","token-level confidence scores"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-zai-org--codegeex__cap_4","uri":"capability://code.generation.editing.distributed.multi.gpu.inference.with.model.parallelism","name":"distributed multi-gpu inference with model parallelism","description":"Distributes the 13B-parameter model across multiple GPUs using Megatron-LM style model parallelism, reducing per-GPU memory requirements to 6GB+ each. The deployment pipeline involves checkpoint conversion (scripts/convert_ckpt_parallel.sh) to shard model weights across GPUs, followed by parallel inference execution (scripts/test_inference_parallel.sh) that coordinates forward passes across devices. This approach enables inference on clusters of smaller GPUs or reduces latency through pipeline parallelism.","intents":["Deploy CodeGeeX on clusters of 4-8 smaller GPUs (6GB each) instead of single large GPU (27GB)","Reduce inference latency through pipeline parallelism across multiple devices","Scale inference throughput for multi-tenant services by distributing model across available GPUs"],"best_for":["teams with clusters of mid-range GPUs (e.g., RTX 3060, A10) but no single large GPU","inference services requiring low-latency responses through pipeline parallelism","organizations with heterogeneous GPU clusters wanting to maximize hardware utilization"],"limitations":["Checkpoint conversion (convert_ckpt_parallel.sh) is a one-time offline process; requires careful orchestration","Inter-GPU communication overhead (NVLink or PCIe) adds latency; benefits depend on GPU interconnect bandwidth","Requires careful tuning of pipeline stages and batch sizes; no automatic optimization","Debugging distributed inference is complex; failures in one GPU affect entire pipeline","Minimum 4 GPUs recommended; diminishing returns with more than 8 GPUs due to communication overhead"],"requires":["Python 3.7+","PyTorch 1.9+ with distributed training support","2-8 GPUs with 6GB+ VRAM each","High-bandwidth GPU interconnect (NVLink preferred; PCIe 4.0 acceptable)","Model checkpoint and conversion utilities","NCCL 2.0+ for GPU communication"],"input_types":["natural language descriptions","partial code snippets","function signatures"],"output_types":["executable code","multiple candidate completions","token-level confidence scores"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-zai-org--codegeex__cap_5","uri":"capability://data.processing.analysis.humaneval.x.multilingual.code.generation.benchmark.with.820.problems","name":"humaneval-x multilingual code generation benchmark with 820 problems","description":"Provides a standardized evaluation platform (HumanEval-X benchmark) with 820 hand-crafted programming problems across Python, C++, Java, JavaScript, and Go. The benchmark includes functional correctness testing infrastructure that executes generated code against test cases, measuring pass@k metrics (percentage of problems solved with k attempts). Evaluation pipeline integrates with code generation utilities to automate the process of generating solutions, executing them, and computing metrics.","intents":["Measure and compare code generation quality across multiple languages using standardized metrics","Evaluate custom fine-tuned models against the same benchmark for reproducible comparisons","Track model improvements over time with consistent evaluation methodology","Identify language-specific weaknesses in code generation (e.g., C++ vs Python performance)"],"best_for":["researchers developing or fine-tuning code generation models","teams evaluating CodeGeeX for production deployment and need quality baselines","organizations comparing multiple code generation approaches (CodeGeeX vs Codex vs Copilot)"],"limitations":["820 problems may not cover all programming paradigms or domain-specific code patterns","Functional correctness testing requires executable environment for each language (Python, C++, Java, JavaScript, Go)","Test cases may have edge cases or corner cases not covered by the benchmark","Pass@k metric doesn't measure code quality, readability, or efficiency — only correctness","Benchmark is static; no mechanism to add new problems or update test cases"],"requires":["Python 3.7+","Compilers/interpreters for all target languages: Python 3.6+, C++ (g++/clang), Java 8+, Node.js 12+, Go 1.13+","CodeGeeX model and inference infrastructure","Sufficient disk space for generated code and test outputs"],"input_types":["problem descriptions (natural language + function signature)","test cases (input/output pairs)","language specification"],"output_types":["generated code solutions","pass@k metrics (pass@1, pass@10, pass@100)","per-language performance breakdown","execution logs and error traces"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-zai-org--codegeex__cap_6","uri":"capability://text.generation.language.code.explanation.and.natural.language.summarization","name":"code explanation and natural language summarization","description":"Generates natural language explanations of code snippets and function summaries by leveraging the Transformer decoder's ability to produce text from code tokens. The IDE extension exposes this capability through a 'explain code' interaction mode that sends selected code to the inference server and returns a human-readable explanation. Summarization works similarly, generating concise descriptions of function behavior, parameters, and return values.","intents":["Understand unfamiliar code by requesting AI-generated explanations without reading documentation","Generate docstrings and comments for undocumented legacy code","Quickly summarize function behavior for code review or onboarding","Translate code logic into natural language for non-technical stakeholders"],"best_for":["developers reading unfamiliar codebases or learning new languages","teams documenting legacy code without original authors","code reviewers needing quick summaries of large functions"],"limitations":["Explanations are generated by the model; may be inaccurate or miss subtle logic","No semantic understanding — explanations based on pattern matching, not true comprehension","Limited to code that fits within 2,048 token context window","Quality depends on code clarity; obfuscated or unusual code produces poor explanations","No ability to ask follow-up questions or request explanations of specific parts"],"requires":["Python 3.7+","CodeGeeX inference server (15GB+ VRAM quantized, 27GB FP16)","VS Code or JetBrains IDE with CodeGeeX extension","Model checkpoint and tokenizer"],"input_types":["code snippet (function, class, or code block)","optional context (surrounding code, file type)"],"output_types":["natural language explanation (1-5 sentences)","function summary (parameter descriptions, return value, behavior)","generated docstring (Python docstring format)"],"categories":["text-generation-language","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-zai-org--codegeex__cap_7","uri":"capability://automation.workflow.docker.containerized.deployment.with.nvidia.gpu.support","name":"docker containerized deployment with nvidia gpu support","description":"Provides a Docker image (codegeex/codegeex:latest) with all dependencies pre-configured for GPU-accelerated inference. The container includes Python 3.7+, PyTorch, CUDA 11.0+, and CodeGeeX model checkpoint, enabling one-command deployment via docker run with NVIDIA Docker runtime. Container supports both single-GPU and multi-GPU inference through environment variable configuration.","intents":["Deploy CodeGeeX inference server in production without manual dependency management","Run CodeGeeX in Kubernetes clusters with GPU support for scalable inference","Quickly spin up isolated CodeGeeX instances for testing or development"],"best_for":["DevOps teams deploying CodeGeeX in containerized environments (Docker, Kubernetes)","organizations with existing Docker/Kubernetes infrastructure","teams needing reproducible, isolated inference environments"],"limitations":["Docker image size is large (~30GB with model checkpoint); slow to pull and deploy","GPU support requires NVIDIA Docker runtime; not compatible with non-NVIDIA GPUs","Container adds ~100-200ms overhead vs bare-metal inference","No built-in orchestration; requires external tools (Kubernetes, Docker Compose) for scaling","Model checkpoint must be included in image or mounted as volume; no dynamic model loading"],"requires":["Docker 20.10+","NVIDIA Docker runtime (nvidia-docker 2.0+)","NVIDIA GPU with 15GB+ VRAM (quantized) or 27GB (FP16)","CUDA 11.0+ compatible GPU"],"input_types":["HTTP requests to inference endpoint (natural language, code snippets)","environment variables for configuration (model size, quantization, GPU count)"],"output_types":["HTTP responses with generated code or explanations","logs and metrics for monitoring"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-zai-org--codegeex__cap_8","uri":"capability://data.processing.analysis.tokenization.with.extended.vocabulary.for.multilingual.code","name":"tokenization with extended vocabulary for multilingual code","description":"Uses a GPT-2 tokenizer extended with whitespace tokens to create a 50,400-token vocabulary optimized for code across 23 programming languages. The tokenizer preserves whitespace significance (critical for Python indentation) and includes language-specific tokens for common keywords and operators. Tokenization is applied uniformly across all languages, enabling the same vocabulary for multilingual generation without language-specific tokenizers.","intents":["Efficiently encode code in multiple languages using a single shared vocabulary","Preserve whitespace and indentation information critical for Python and other whitespace-sensitive languages","Reduce token count for code by including common programming keywords and operators"],"best_for":["multilingual code generation systems needing a unified tokenization approach","developers building custom fine-tuned models on top of CodeGeeX"],"limitations":["50,400 vocabulary size is fixed; no dynamic vocabulary expansion for new languages or domains","Whitespace tokens increase vocabulary size compared to standard GPT-2 tokenizer","Tokenization is language-agnostic; no language-specific optimizations (e.g., camelCase splitting for Java)","No subword tokenization for non-ASCII characters; may require multiple tokens for Unicode symbols"],"requires":["Python 3.7+","Tokenizer checkpoint (included in CodeGeeX distribution)","No external dependencies for tokenization"],"input_types":["code text in any of 23 supported languages","natural language descriptions"],"output_types":["token IDs (integers 0-50399)","token strings (for debugging)"],"categories":["data-processing-analysis","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-zai-org--codegeex__cap_9","uri":"capability://automation.workflow.checkpoint.management.and.model.loading.with.format.conversion","name":"checkpoint management and model loading with format conversion","description":"Provides utilities for loading, converting, and managing model checkpoints across different formats and deployment scenarios. The codegeex/torch/get_ckpt_qkv.py script extracts query-key-value projections for quantization, while convert_ckpt_parallel.sh converts checkpoints for distributed inference. Checkpoint management supports FP16 (27GB), 8-bit quantized (15GB), and parallel-distributed formats, with explicit conversion pipelines for each deployment mode.","intents":["Load pre-trained CodeGeeX checkpoints for inference without manual weight extraction","Convert checkpoints between formats (FP16 → quantized, single-GPU → multi-GPU)","Manage multiple checkpoint versions for A/B testing or rollback"],"best_for":["DevOps teams managing CodeGeeX deployments across multiple hardware configurations","researchers fine-tuning CodeGeeX and needing to convert checkpoints for inference"],"limitations":["Checkpoint conversion is a one-time offline process; requires careful orchestration and validation","No automatic format detection; users must specify target format explicitly","Conversion scripts are format-specific; adding new formats requires new scripts","Large checkpoint size (26GB) makes conversion slow and storage-intensive","No versioning or rollback mechanism; old checkpoints must be manually archived"],"requires":["Python 3.7+","PyTorch 1.9+","Sufficient disk space (26GB per checkpoint + converted formats)","Conversion scripts (get_ckpt_qkv.py, convert_ckpt_parallel.sh)"],"input_types":["model checkpoint file (PyTorch .pt or .pth format)","target format specification (FP16, quantized, parallel)"],"output_types":["converted checkpoint in target format","conversion logs and validation results"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":34,"verified":false,"data_access_risk":"high","permissions":["Python 3.7+","PyTorch 1.9+ or OneFlow framework","GPU with 27GB VRAM (FP16) or 15GB (8-bit quantized)","Model checkpoint (13B parameters, ~26GB disk space)","CUDA 11.0+ for GPU acceleration","PyTorch 1.9+ or OneFlow","GPU with 15GB+ VRAM (quantized) or 27GB (FP16)","Model checkpoint and tokenizer","Multiple GPUs (8+ recommended) or TPUs for distributed training","Training data in supported format (code files or tokenized datasets)"],"failure_modes":["Maximum sequence length of 2,048 tokens limits context for very large files or complex multi-file generation","Training data cutoff at June 2022 means no knowledge of recent language features or libraries","Single-GPU deployment requires >27GB VRAM; quantization to 15GB introduces precision loss affecting code quality","No built-in semantic validation — generated code may be syntactically correct but logically incorrect","Cross-language generation quality varies; performance strongest on Python, weaker on C++ and Go","No semantic validation — translated code may compile but not preserve original behavior","Language-specific idioms and performance patterns often lost in translation (e.g., Python list comprehensions → Java streams)","Requires source code fit within 2,048 tokens; large functions must be split manually","No awareness of language-specific libraries or APIs — may generate non-existent function calls","Type system mismatches (e.g., Python duck typing → Java static typing) require manual post-processing","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.3421503259726236,"quality":0.34,"ecosystem":0.48999999999999994,"match_graph":0.25,"freshness":0.52,"weights":{"adoption":0.35,"quality":0.2,"ecosystem":0.1,"match_graph":0.3,"freshness":0.05}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:22.064Z","last_scraped_at":"2026-05-03T13:58:37.059Z","last_commit":"2024-08-13T05:59:38Z"},"community":{"stars":8774,"forks":689,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=zai-org--codegeex","compare_url":"https://unfragile.ai/compare?artifact=zai-org--codegeex"}},"signature":"i/sattsGMNXOz2LYTbeVvKtZSeXGHbC2SYijK5d3L8NCwWkwmMSbWZ1X0SMbmhGtTyWhajxNGNCjVBToEoGqAw==","signedAt":"2026-06-20T06:00:30.217Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/zai-org--codegeex","artifact":"https://unfragile.ai/zai-org--codegeex","verify":"https://unfragile.ai/api/v1/verify?slug=zai-org--codegeex","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"}}