Comet 60B

Comet 60B is an open-source multimodal Mixture-of-Experts (MoE) model developed by Multiverse Computing. Created by applying the company's proprietary CompactifAI compression framework to NVIDIA's 124.5B-parameter Nemotron 3.5 Super VL, Comet 60B halves the base parameter footprint down to 61.1B total parameters while retaining the original model's 12.8B active parameters per token. The architecture takes text, image, and video inputs to generate text, pairing strong visual and linguistic reasoning with an operational footprint that fits on half the compute required by its parent model.

For engineers and infrastructure teams looking to deploy vision-language agents without the operational overhead of 100B+ parameter checkpoints, Comet 60B fills a distinct operational niche. Where its predecessor required a minimum 4-GPU node of enterprise silicon just to host the weights in uncompressed formats, Comet 60B brings multimodal agentic capabilities into reach for smaller private clusters and high-end local workstations. Model weights are released under the NVIDIA Nemotron Open Model License, clearing it for production commercial deployments across self-hosted and air-gapped environments.

Under the hood, Comet 60B retains the core structural design of NVIDIA Nemotron 3.5 Super VL: a hybrid Mamba2-Transformer MoE network consisting of 88 layers (40 Mamba2 layers, 40 MoE layers, and 8 attention layers) alongside a Multi-Token Prediction (MTP) layer and a 32-layer RADIO ViT-H/16 vision encoder. The hidden dimension spans 4,096, with routed experts operating in a 1,024-dimensional latent space.

1Total Parameters:        61.1B
2Active Parameters/Token: 12.8B (22 of 512 routed experts + 1 shared expert)
3Model Architecture:      Hybrid Mamba2-Attention Mixture of Experts (MoE)
4Vision Backbone:         RADIO ViT-H/16 encoder (approx. 0.8B parameters)
5Multi-Token Prediction:  Retained (2.9B parameter MTP layer)
6Input Modalities:        Text, Images, Video
7Output Modality:         Text
8License:                 NVIDIA Nemotron Open Model License (Commercial use permitted)

The key to Comet 60B MoE efficiency lies in how Multiverse Computing applied CompactifAI. Rather than uniformly pruning weights, the compression pipeline targeted the parameter-dense routed experts, which previously accounted for the vast majority of memory overhead. By compressing the expert weights and subsequently healing the model via knowledge distillation on multimodal tokens, Comet 60B cuts memory storage requirements by 50% while holding active compute steady at 12.8B parameters.

Because inference speed in MoE architectures is governed primarily by active parameters during generation and total parameters during memory bandwidth transfers, Comet 60B achieves higher throughput per GPU. The retained MTP layer also enables native speculative decoding out of the box, allowing inference engines like vLLM to decode multiple tokens per forward pass without requiring a separate draft model.

Comet 60B targets complex agentic pipelines that require processing interleaved visual assets and dense instructional context. It supports native function-calling, configurable reasoning traces, and multi-turn chat:

• Agentic Workflows and Tool Calling: Comet 60B matches or exceeds its 124.5B parent on key agentic evaluations, including τ²-Bench (airline, retail, and telecom scenarios) and AutomationBench-AA. Its native support for vLLM tool parsers allows developers to build structured agents that interface directly with SQL databases, internal APIs, and web scrapers.
• Multimodal Document and Video Processing: Utilizing the RADIO ViT-H/16 vision encoder, the model ingests high-resolution images, charts, and video inputs. Practical applications include parsing multi-page scanned PDF reports, automated video surveillance summarization, visual QA for industrial schematics, and defect detection in manufacturing.
• Software Engineering and Code Generation: In software-focused benchmarks like SWE-bench Pro and SWE-bench Verified, Comet 60B demonstrates strong code comprehension and patch generation across complex repository structures. It handles multi-file refactoring, debugging trace analysis, and test case generation.
• Structured Reasoning: The model exposes configurable reasoning controls, enabling deep step-by-step thinking for math and logic-heavy workflows. In evaluations like GPQA Diamond and AA-LCR, Comet 60B stays within 3 points of the full-size Nemotron 3.5 Super VL while requiring significantly less memory bandwidth.

Deploying this local AI model with 61.1B parameters in 2026 requires understanding the split between total parameter storage and active compute. While only 12.8B parameters execute per token, the entire 61.1B parameter weight graph must reside in memory (VRAM or system RAM) to avoid steep offloading penalties.

The memory required to run Comet 60B locally depends directly on precision and context consumption:

• BF16 (16-bit): Checkpoint size is 122.3 GB. Requires at least 140 GB to 160 GB of VRAM to allow room for the KV cache. Hardware target: 2x NVIDIA H100/H200 (141 GB H200 can run it on a single card with reduced context, but 2x is standard).
• FP8 (8-bit): Checkpoint size is 66.3 GB. Requires 80 GB to 96 GB of usable VRAM. Hardware target: 1x NVIDIA H100/H200 or 2x RTX 6000 Ada / 2x A100 (80 GB).
• NVFP4 (4-bit, Blackwell): Checkpoint size is 40.5 GB. Designed specifically for next-gen hardware architectures supporting native microvector FP4 formats.
• GGUF / EXL2 (4-bit Quantization, e.g., Q4_K_M): Checkpoint size drops to roughly 35 GB to 38 GB. Requires 48 GB of total memory to hold weights and a moderate KV cache.

Running a 61.1B model on consumer GPU setups requires multi-GPU pooling or unified memory:

• Dual GeForce RTX 4090 (2x 24 GB = 48 GB VRAM): By leveraging Q4_K_M GGUF or EXL2 quantization, you can split the 36 GB weight footprint across two 24 GB cards via PCIe. This leaves roughly 8 GB to 10 GB of pooled VRAM for KV cache. Expect roughly 25 to 40 Comet 60B tokens per second depending on pipeline parallelism overhead and sequence length.
• Apple Silicon (M3 Max / M4 Max with 64 GB, 96 GB, or 128 GB Unified Memory): An M4 Max with 64 GB or 128 GB memory easily loads a 4-bit or 5-bit GGUF checkpoint into unified RAM with zero PCIe bottleneck. An M4 Max (128 GB) running llama.cpp can achieve 18 to 30 tokens per second on the 12.8B active parameter path.
• Single RTX 4090 or RTX 3090 (24 GB VRAM): You cannot fit Comet 60B entirely into 24 GB VRAM even at 3-bit quantization without crippling degradation. Partial GPU offloading to system RAM via CPU inference is possible, but generation speeds will drop to 3 to 6 tokens per second due to DDR5 memory bandwidth bottlenecks.

The fastest way to test Comet 60B locally is through Ollama or llama.cpp once GGUF weights are prepared:

1# Pull and run Comet 60B via Ollama (Q4_K_M default when available)
2ollama run comet-60b
3
4# Test multimodal visual inputs directly via CLI
5ollama run comet-60b "Describe the failure point in this schematic: /path/to/diagram.png"

For production multi-GPU serving, use vLLM to take advantage of native MTP speculative decoding, FP8 execution, and the built-in Nemotron reasoning parser:

1vllm serve MultiverseComputingCAI/Comet-1.0-60B-FP8 \
2    --tensor-parallel-size 2 \
3    --enable-speculative-decoding \
4    --trust-remote-code

Evaluating Comet 60B against competing architectures highlights the practical tradeoffs of compressed MoE networks:

Comet 60B delivers 95% to 100% of the original model's accuracy across standard multimodal and coding benchmarks (staying within 3 points on 28 of 35 standard tests) while slashing the VRAM footprint in half. On the same 4x H200 cluster, Comet delivers 20% to 23% faster generation throughput. Choose Comet 60B unless you require the absolute edge-case reasoning performance of the full 124.5B model and have surplus enterprise GPUs available.

Qwen2.5-VL 72B is a dense vision-language model. Because it activates all 72B parameters for every generated token, it demands massive compute per step. In contrast, Comet 60B activates only 12.8B parameters per token. While both models require similar total VRAM to hold weights in 4-bit (around 38 GB to 45 GB), Comet 60B processes generation significantly faster on dual-GPU or unified memory rigs due to its lower per-token compute demands. Choose Qwen2.5-VL 72B for dense, document-heavy OCR precision; choose Comet 60B for high-throughput agent loops, coding tasks, and real-time tool calling.