{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"map-neo","slug":"map-neo","name":"MAP-Neo","type":"repo","url":"https://github.com/multimodal-art-projection/map-neo","page_url":"https://unfragile.ai/map-neo","categories":["model-training"],"tags":[],"pricing":{"model":"free","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"map-neo__cap_0","uri":"capability://code.generation.editing.end.to.end.reproducible.language.model.training.pipeline","name":"end-to-end reproducible language model training pipeline","description":"Provides a complete, open-source training pipeline that includes data collection, preprocessing, tokenization, model training, and evaluation stages with intermediate checkpoints saved at regular intervals. The pipeline is designed for full transparency and reproducibility, allowing researchers to inspect every stage of model development from raw data through final weights. Implements standard transformer architecture training with distributed training support and comprehensive logging of hyperparameters and training metrics.","intents":["I want to train a language model from scratch and understand exactly what data and methods were used","I need to reproduce or verify the training process of an existing model to validate research claims","I want to modify the training pipeline for my own bilingual or multilingual model variants","I need intermediate checkpoints to study how model capabilities emerge during training"],"best_for":["LLM researchers conducting reproducibility studies","academic teams building open-source model baselines","developers creating custom bilingual models for specific language pairs","organizations requiring full transparency in model provenance for compliance"],"limitations":["Training from scratch requires significant computational resources (GPU/TPU clusters), making it inaccessible for individual researchers without institutional support","Pipeline is optimized for the specific language pairs and data distributions used in MAP-Neo; generalization to other language pairs requires substantial pipeline modification","No built-in distributed training orchestration — requires manual setup of multi-GPU/multi-node coordination","Checkpoint storage can consume terabytes of disk space for full intermediate model states"],"requires":["Python 3.8+","PyTorch 1.12+ or TensorFlow 2.10+","CUDA 11.0+ for GPU training (or TPU access for large-scale training)","Sufficient storage for datasets and checkpoints (minimum 500GB recommended)","Git for version control and reproducibility tracking"],"input_types":["raw text corpora (multilingual documents)","configuration files (YAML/JSON for hyperparameters)","tokenizer specifications"],"output_types":["trained model weights (safetensors or PyTorch format)","intermediate checkpoints at specified intervals","training logs and metrics (JSON/CSV)","evaluation results and benchmarks"],"categories":["code-generation-editing","model-training","reproducible-research"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"map-neo__cap_1","uri":"capability://data.processing.analysis.bilingual.data.collection.and.preprocessing.pipeline","name":"bilingual data collection and preprocessing pipeline","description":"Implements a multi-stage data pipeline for collecting, cleaning, and preparing bilingual text corpora for model training. The pipeline handles language detection, deduplication, quality filtering, and alignment of parallel text across language pairs. Uses configurable preprocessing rules to normalize text, remove low-quality documents, and balance data distribution between languages to prevent training bias toward high-resource languages.","intents":["I need to collect and clean large-scale bilingual training data without introducing quality issues or language imbalance","I want to filter out low-quality or toxic content from raw web-scraped text before training","I need to understand the composition and quality metrics of my training dataset","I want to create balanced training data that doesn't favor one language over another"],"best_for":["NLP researchers building bilingual or multilingual models","teams creating language models for underrepresented language pairs","organizations needing to audit and validate training data quality","developers implementing custom data pipelines for specific language combinations"],"limitations":["Language detection accuracy varies by script and code-switching scenarios; may misclassify mixed-language documents","Deduplication is computationally expensive at scale (O(n log n) for exact matching, higher for fuzzy matching)","Quality filtering rules are heuristic-based and may remove valid content or retain low-quality documents depending on threshold tuning","No built-in handling of copyright or licensing compliance — requires manual verification of data sources"],"requires":["Python 3.8+","langdetect or similar language detection library","pandas/polars for data manipulation","sufficient RAM for in-memory deduplication (scales with corpus size)","access to raw text corpora or web scraping infrastructure"],"input_types":["raw text files (UTF-8 encoded)","web-scraped HTML/JSON documents","parallel corpora (aligned sentence pairs)","configuration files specifying preprocessing rules"],"output_types":["cleaned and deduplicated text corpora","dataset statistics and quality metrics (JSON)","language distribution reports","filtered document lists with quality scores"],"categories":["data-processing-analysis","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"map-neo__cap_10","uri":"capability://data.processing.analysis.bilingual.model.evaluation.on.language.specific.benchmarks","name":"bilingual model evaluation on language-specific benchmarks","description":"Evaluates bilingual models on language-specific benchmarks and multilingual tasks, measuring performance across both languages and analyzing language-specific strengths and weaknesses. The evaluation framework supports custom benchmarks and provides detailed analysis of cross-lingual transfer and language interference.","intents":["I want to measure model performance on both languages in my bilingual model","I need to identify language-specific weaknesses and biases","I want to analyze cross-lingual transfer and language interference effects","I need to compare bilingual model performance against monolingual baselines"],"best_for":["researchers studying bilingual language models and cross-lingual transfer","teams building multilingual models for global audiences","developers optimizing models for specific language pairs","organizations ensuring fair performance across languages"],"limitations":["Benchmark availability varies significantly across languages; some languages lack standard benchmarks","Evaluation metrics may not be comparable across languages due to linguistic differences","Language-specific biases in benchmarks may not be detected; requires careful analysis","Cross-lingual transfer analysis requires careful experimental design; confounding factors are common","No built-in support for low-resource languages; evaluation may be limited to high-resource pairs"],"requires":["Python 3.8+","multilingual benchmark datasets (XNLI, MLQA, etc.)","language-specific evaluation tools and metrics","GPU for inference (can use smaller GPU than training)"],"input_types":["trained bilingual model","benchmark dataset specifications (task names, language pairs)","evaluation hyperparameters (batch size, max tokens)"],"output_types":["per-language evaluation metrics (accuracy, F1, perplexity)","cross-lingual transfer analysis (performance correlation across languages)","language-specific strength/weakness analysis","comparison tables and visualizations"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"map-neo__cap_2","uri":"capability://data.processing.analysis.tokenizer.training.and.vocabulary.optimization","name":"tokenizer training and vocabulary optimization","description":"Implements a configurable tokenizer training system that learns vocabulary from bilingual corpora using byte-pair encoding (BPE) or similar subword tokenization algorithms. The system optimizes vocabulary size and merging strategies to balance compression efficiency across both languages, preventing vocabulary bias toward high-resource languages. Produces serialized tokenizer artifacts that can be versioned and reproduced, with detailed statistics on token distribution and compression ratios.","intents":["I want to train a tokenizer that handles both languages efficiently without favoring one language's vocabulary","I need to understand how my model tokenizes text and optimize vocabulary size for inference speed","I want to reproduce the exact tokenizer used in a published model for fair comparison","I need to create specialized tokenizers for domain-specific or low-resource language pairs"],"best_for":["NLP researchers optimizing tokenization for multilingual models","teams building models for language pairs with different morphological complexity","developers implementing custom tokenizers for specialized domains","researchers studying the impact of tokenization choices on model performance"],"limitations":["BPE training is greedy and not globally optimal — different merge orders can produce different vocabularies with similar compression ratios","Vocabulary size is a manual hyperparameter with no principled way to determine optimal size; requires empirical tuning","Tokenizer training is deterministic but sensitive to corpus composition; small changes in training data can produce different vocabularies","No built-in support for morphological analysis or linguistic-aware tokenization; purely statistical approach"],"requires":["Python 3.8+","sentencepiece or tokenizers library (Hugging Face)","bilingual training corpora (minimum 1GB recommended for stable vocabulary)","sufficient RAM for vocabulary statistics computation"],"input_types":["raw or preprocessed text corpora","configuration files specifying vocabulary size and merging strategy","existing tokenizer models (for fine-tuning)"],"output_types":["serialized tokenizer model (sentencepiece .model or tokenizers .json)","vocabulary files with token frequencies","tokenization statistics and compression metrics","test tokenization examples for validation"],"categories":["data-processing-analysis","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"map-neo__cap_3","uri":"capability://code.generation.editing.distributed.transformer.model.training.with.checkpointing","name":"distributed transformer model training with checkpointing","description":"Implements distributed training of transformer-based language models using data parallelism and gradient accumulation across multiple GPUs or TPUs. The system includes automatic mixed precision (AMP) training for memory efficiency, gradient checkpointing to reduce memory footprint, and periodic checkpoint saving at configurable intervals. Supports resuming training from checkpoints with automatic learning rate scheduling and loss tracking across training steps.","intents":["I want to train a large transformer model efficiently across multiple GPUs without running out of memory","I need to save intermediate model states during training to study capability emergence and enable recovery from failures","I want to use mixed precision training to reduce memory usage and training time","I need to resume training from a checkpoint after interruption without losing progress"],"best_for":["researchers training large language models with limited GPU memory","teams conducting long-running training experiments requiring fault tolerance","developers studying how model capabilities emerge during training via intermediate checkpoints","organizations optimizing training efficiency and cost"],"limitations":["Distributed training introduces synchronization overhead; scaling efficiency degrades beyond 8-16 GPUs due to communication bottlenecks","Gradient checkpointing trades memory for computation — reduces memory by ~30-40% but increases training time by 10-20%","Mixed precision training can introduce numerical instability in certain scenarios; requires careful tuning of loss scaling","Checkpoint saving is I/O bound; frequent checkpointing can significantly slow training (10-30% overhead depending on model size and storage speed)"],"requires":["Python 3.8+","PyTorch 1.12+ with CUDA support or TensorFlow 2.10+","NVIDIA GPUs (A100, H100) or TPU access for practical training","distributed training framework (torch.distributed or tf.distribute)","high-speed storage for checkpoint I/O (NVMe SSD or network storage with low latency)"],"input_types":["preprocessed training data (tokenized text in binary format)","model configuration (architecture, hidden size, number of layers)","training hyperparameters (learning rate, batch size, number of steps)","checkpoint files (for resuming training)"],"output_types":["trained model weights at specified checkpoints","training logs with loss, perplexity, and learning rate curves","checkpoint metadata (step number, timestamp, training configuration)","final model weights and tokenizer"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"map-neo__cap_4","uri":"capability://data.processing.analysis.comprehensive.model.evaluation.and.benchmarking","name":"comprehensive model evaluation and benchmarking","description":"Implements a suite of evaluation metrics and benchmarks for assessing language model performance across multiple dimensions including perplexity, downstream task performance (classification, QA, generation), and language-specific metrics. The system runs standardized benchmarks on intermediate checkpoints to track capability emergence, supports both automatic metrics (BLEU, ROUGE, F1) and human evaluation protocols, and generates detailed evaluation reports comparing performance across languages and tasks.","intents":["I want to measure how well my bilingual model performs on standard benchmarks and compare it to published baselines","I need to track how model capabilities improve during training by evaluating intermediate checkpoints","I want to understand performance differences between the two languages in my bilingual model","I need to evaluate my model on domain-specific tasks beyond standard benchmarks"],"best_for":["researchers publishing language models and needing comprehensive evaluation","teams comparing model variants and making architectural decisions based on benchmark results","developers studying how capabilities emerge during training","organizations validating model quality before deployment"],"limitations":["Automatic metrics (BLEU, ROUGE) have known limitations and don't always correlate with human judgment; require supplementary human evaluation for critical applications","Benchmark performance may not reflect real-world performance on out-of-distribution tasks or user-specific use cases","Evaluating all checkpoints is computationally expensive; typically requires sampling checkpoints or running evaluation asynchronously","Language-specific metrics are limited for low-resource languages; standard benchmarks may not exist or may be small/noisy"],"requires":["Python 3.8+","evaluation libraries (evaluate, nltk, sacrebleu)","benchmark datasets (GLUE, SuperGLUE, MMLU, or custom datasets)","sufficient compute for running inference on evaluation sets (GPU recommended)","reference implementations for metric computation"],"input_types":["trained model checkpoints","evaluation datasets (text, labels, references)","evaluation configuration (which benchmarks to run, metric parameters)","baseline results for comparison"],"output_types":["evaluation metrics (perplexity, accuracy, F1, BLEU, ROUGE scores)","benchmark results tables and comparison charts","per-checkpoint evaluation curves showing capability emergence","detailed error analysis and failure case documentation"],"categories":["data-processing-analysis","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"map-neo__cap_5","uri":"capability://automation.workflow.configuration.driven.training.experiment.management","name":"configuration-driven training experiment management","description":"Implements a configuration-based system for defining, launching, and tracking training experiments using YAML or JSON configuration files that specify model architecture, data pipeline, training hyperparameters, and evaluation settings. The system automatically logs all configuration parameters, random seeds, and environment details to enable perfect reproducibility. Supports experiment versioning, parameter sweeps, and automated result aggregation across multiple runs.","intents":["I want to run multiple training experiments with different hyperparameters and track results systematically","I need to reproduce an exact training run from a published paper by using the same configuration file","I want to automate hyperparameter tuning by running a grid or random search over parameter spaces","I need to document all training decisions and make them reproducible for future reference"],"best_for":["researchers conducting systematic hyperparameter studies","teams publishing models and needing to document all training decisions","developers managing multiple model variants and training runs","organizations requiring audit trails and reproducibility for compliance"],"limitations":["Configuration-based approach can become verbose for complex experiments; requires careful schema design to remain usable","Parameter sweeps grow exponentially with number of parameters; full grid search is infeasible for large parameter spaces","Configuration files don't capture all non-determinism (e.g., floating-point operation order in distributed training); perfect reproducibility is not guaranteed","Experiment tracking requires external storage (database or file system); no built-in experiment versioning or collaboration features"],"requires":["Python 3.8+","YAML/JSON parsing libraries","logging framework (Python logging or custom)","experiment tracking tool (optional: Weights & Biases, MLflow, or custom)","version control system (Git) for configuration files"],"input_types":["YAML/JSON configuration files","command-line arguments for overriding configuration","environment variables for secrets and paths"],"output_types":["experiment logs with all configuration parameters","trained model checkpoints tagged with experiment ID","evaluation results linked to specific configurations","experiment comparison reports and parameter sensitivity analysis"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"map-neo__cap_6","uri":"capability://data.processing.analysis.model.weight.serialization.and.versioning","name":"model weight serialization and versioning","description":"Implements serialization of trained model weights in multiple formats (safetensors, PyTorch, HuggingFace format) with automatic versioning, metadata embedding, and integrity checking. The system tracks model provenance including training configuration, data sources, and training date, enabling users to verify model authenticity and understand its origin. Supports efficient weight loading with lazy initialization for large models.","intents":["I want to save and load trained model weights in a format that's compatible with standard tools and frameworks","I need to verify that a model I downloaded hasn't been tampered with and matches the published version","I want to understand the provenance of a model including what data it was trained on and when","I need to efficiently load very large models without loading all weights into memory at once"],"best_for":["researchers publishing models and needing to ensure reproducibility and authenticity","developers integrating models into production systems","organizations requiring model provenance tracking for compliance","users downloading and validating open-source models"],"limitations":["Multiple serialization formats (safetensors, PyTorch, HuggingFace) create compatibility issues; not all frameworks support all formats equally","Model weights are large (billions of parameters); storage and download bandwidth are significant bottlenecks","Metadata embedding increases file size; requires careful design to avoid excessive overhead","Integrity checking (checksums, signatures) requires additional infrastructure and key management"],"requires":["Python 3.8+","PyTorch or TensorFlow for weight serialization","safetensors library for efficient serialization","sufficient storage for model weights (typically 10-100GB+ for large models)","optional: cryptographic libraries for integrity checking"],"input_types":["trained model weights (in-memory tensors)","model configuration (architecture, hyperparameters)","metadata (training date, data sources, author)"],"output_types":["serialized model files (safetensors, .pt, .bin formats)","model cards with metadata and provenance information","checksums or signatures for integrity verification","version tags and release notes"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"map-neo__cap_7","uri":"capability://text.generation.language.training.documentation.and.reproducibility.artifacts","name":"training documentation and reproducibility artifacts","description":"Generates comprehensive documentation of the training process including detailed descriptions of data sources, preprocessing steps, model architecture, hyperparameters, and training procedures. The system produces reproducibility artifacts such as dependency specifications (requirements.txt, environment.yml), training scripts, and detailed README files that enable other researchers to understand and reproduce the training process. Includes links to intermediate checkpoints and evaluation results for full transparency.","intents":["I want to understand exactly how a published model was trained so I can reproduce it or build upon it","I need to document my training process thoroughly for publication or sharing with collaborators","I want to create a reproducible training environment that others can use to verify my results","I need to provide clear instructions for using the model and understanding its capabilities and limitations"],"best_for":["researchers publishing models and needing to meet reproducibility standards","teams collaborating on model development and needing shared documentation","organizations releasing open-source models to the community","educators teaching LLM training and needing transparent, well-documented examples"],"limitations":["Comprehensive documentation requires significant effort and expertise; many researchers lack time or incentive to document thoroughly","Documentation can become outdated as code evolves; requires active maintenance to stay accurate","Some training details may be proprietary or sensitive (e.g., specific data sources, computational costs); full transparency may not always be possible","Documentation quality varies widely; even well-intentioned documentation may lack sufficient detail for true reproducibility"],"requires":["Python 3.8+","documentation tools (Markdown, Sphinx, or similar)","version control system (Git) for tracking documentation changes","time and expertise to write clear, comprehensive documentation","access to training infrastructure details and logs"],"input_types":["training code and configuration files","training logs and metrics","model checkpoints and evaluation results","data source information and preprocessing details"],"output_types":["README files with overview and quick-start instructions","detailed training documentation with methodology","model cards with capabilities, limitations, and intended use","dependency specifications (requirements.txt, environment.yml)","links to data sources, code repositories, and checkpoints"],"categories":["text-generation-language","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"map-neo__cap_8","uri":"capability://automation.workflow.reproducible.random.seed.management.and.determinism","name":"reproducible random seed management and determinism","description":"Implements deterministic training through careful random seed management across PyTorch, NumPy, and Python's random module, with explicit documentation of non-deterministic operations. The system ensures that training runs with identical configurations produce identical results, enabling perfect reproducibility for research and debugging.","intents":["I want to reproduce a training run exactly, including all stochastic operations","I need to debug training issues by comparing runs with identical seeds","I want to ensure my research results are reproducible by others","I need to identify sources of non-determinism in my training pipeline"],"best_for":["researchers conducting reproducible LLM research","teams debugging training instability and convergence issues","organizations publishing research with reproducibility guarantees","developers ensuring consistent model behavior across deployments"],"limitations":["Perfect determinism requires disabling GPU optimizations; may reduce training speed by 5-15%","Some CUDA operations (e.g., scatter/gather) are inherently non-deterministic; workarounds may be slow","Distributed training introduces non-determinism from network timing; requires careful synchronization","Floating-point arithmetic is non-associative; different operation orders produce different results","Documentation of non-deterministic operations is incomplete; some sources of randomness may be missed"],"requires":["Python 3.8+","PyTorch 2.0+ with deterministic mode enabled","CUDA 11.8+ with deterministic algorithms enabled","careful configuration of environment variables (CUBLAS_WORKSPACE_CONFIG, etc.)"],"input_types":["random seed value (integer)","configuration specifying determinism level (strict vs. approximate)"],"output_types":["training logs documenting seed values and determinism settings","warnings about non-deterministic operations","reproducibility reports comparing runs with identical seeds"],"categories":["automation-workflow","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"map-neo__cap_9","uri":"capability://text.generation.language.model.inference.and.generation.with.configurable.decoding.strategies","name":"model inference and generation with configurable decoding strategies","description":"Implements inference and text generation with multiple decoding strategies (greedy, beam search, nucleus sampling, temperature scaling), supporting both batch and streaming inference modes. The system includes optimizations for inference efficiency (KV-cache, attention optimization) and supports quantization for reduced memory footprint.","intents":["I want to generate text from a trained model with different decoding strategies","I need to run inference efficiently on limited hardware","I want to compare generation quality across different decoding parameters","I need to deploy models with reduced memory footprint using quantization"],"best_for":["researchers evaluating generation quality and decoding strategies","teams deploying models to production with inference efficiency requirements","developers building applications using trained models","organizations optimizing inference cost and latency"],"limitations":["Beam search has quadratic memory complexity; limited to small beam widths (typically 1-4)","Nucleus sampling introduces randomness; results are non-deterministic even with fixed seeds","KV-cache optimization requires careful memory management; may cause OOM on long sequences","Quantization reduces model quality; accuracy loss depends on quantization scheme","Streaming inference adds latency overhead; not suitable for latency-critical applications"],"requires":["Python 3.8+","PyTorch 2.0+ with inference optimizations","trained model weights (PyTorch .pt or safetensors format)","optional: quantization libraries (bitsandbytes, GPTQ) for reduced memory"],"input_types":["prompt text (string or token IDs)","decoding parameters (temperature, top_p, top_k, max_length)","optional: system prompts or few-shot examples"],"output_types":["generated text (string)","token IDs and log probabilities","generation metadata (tokens generated, inference time)"],"categories":["text-generation-language","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"map-neo__headline","uri":"capability://model.training.open.source.bilingual.language.model.for.reproducible.llm.research","name":"open-source bilingual language model for reproducible llm research","description":"MAP-Neo is a fully open-source bilingual language model that provides a complete data pipeline and training code, making it ideal for researchers focused on reproducible LLM studies.","intents":["best open-source bilingual language model","bilingual LLM for reproducible research","open-source model training framework","transparent training for language models","LLM research tools and resources"],"best_for":["researchers","developers"],"limitations":[],"requires":[],"input_types":[],"output_types":[],"categories":["model-training"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":55,"verified":false,"data_access_risk":"high","permissions":["Python 3.8+","PyTorch 1.12+ or TensorFlow 2.10+","CUDA 11.0+ for GPU training (or TPU access for large-scale training)","Sufficient storage for datasets and checkpoints (minimum 500GB recommended)","Git for version control and reproducibility tracking","langdetect or similar language detection library","pandas/polars for data manipulation","sufficient RAM for in-memory deduplication (scales with corpus size)","access to raw text corpora or web scraping infrastructure","multilingual benchmark datasets (XNLI, MLQA, etc.)"],"failure_modes":["Training from scratch requires significant computational resources (GPU/TPU clusters), making it inaccessible for individual researchers without institutional support","Pipeline is optimized for the specific language pairs and data distributions used in MAP-Neo; generalization to other language pairs requires substantial pipeline modification","No built-in distributed training orchestration — requires manual setup of multi-GPU/multi-node coordination","Checkpoint storage can consume terabytes of disk space for full intermediate model states","Language detection accuracy varies by script and code-switching scenarios; may misclassify mixed-language documents","Deduplication is computationally expensive at scale (O(n log n) for exact matching, higher for fuzzy matching)","Quality filtering rules are heuristic-based and may remove valid content or retain low-quality documents depending on threshold tuning","No built-in handling of copyright or licensing compliance — requires manual verification of data sources","Benchmark availability varies significantly across languages; some languages lack standard benchmarks","Evaluation metrics may not be comparable across languages due to linguistic differences","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.693Z","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=map-neo","compare_url":"https://unfragile.ai/compare?artifact=map-neo"}},"signature":"9AkTmeeFOjYu6+DlCTTCwn344shbVdfejxMxLWQ2rdmcWOHGBGeByjnZNPb3F7wVSjm50pMIAWQM7mveX/jJAA==","signedAt":"2026-06-22T02:36:42.927Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/map-neo","artifact":"https://unfragile.ai/map-neo","verify":"https://unfragile.ai/api/v1/verify?slug=map-neo","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"}}