Comet 60B

Comet 60B

A 61.1B multimodal model from Multiverse Computing, a compressed version of NVIDIA's Nemotron 3.5 Super that takes text, image and video and keeps about 12B parameters active. It suits teams that serve a large open model with vLLM on fewer GPUs.

Made by MultiverseComputingCAI on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: Comet 60B is a multimodal model from Multiverse Computing, built from NVIDIA's Nemotron 3.5 Super VL 120B. The original is a hybrid Mamba2 and Transformer mixture-of-experts model. Multiverse used its CompactifAI compression to cut the parameter count roughly in half, to 61.1 billion, while about 12 billion stay active for each token. Its layers, tokenizer and chat template stay as they were. After compression the model was retrained by distilling the original on text, image and video data. Inputs can be text, images or video, and it answers in text. Reasoning can be tuned per request, and it can call tools.

Who it suits: It suits teams that run a large open model on their own GPUs and want the same family of abilities with a smaller memory need. It also suits developers who build agents, document readers or video and image assistants.

Title: Who might use it
Industry | Who uses it | How they use it | Example
Software | Platform engineers | Serve one multimodal model on fewer GPUs | Replace a four-GPU setup with two
Agents | Agent builders | Use reasoning and tool calling in an assistant | Let the model call a tool during a task
Media and documents | Analysts | Ask questions about images, documents and video | Summarize a clip or read a scanned page

If you do not have GPU servers, you can skip it. The BF16 files alone are 122.3 GB.

Where to use it: The record lists the transformers library. The card says serving goes through vLLM with the base model's reasoning and tool parsers, and speculative decoding uses its multi-token prediction layer.

• vLLM, using the same parsers as the base model
• Python with transformers
• GPU servers, since the card sizes it in H200 cards

Title: Jobs it does
Use case | Who | What they get back
Image and video questions | Analysts | Written answers about pictures and clips
Agent tasks | Developers | Replies that reason and call tools
Long reasoning | Researchers | Answers with a configurable reasoning mode

How to set it up: You need Python with pip and a server with a lot of GPU memory. The card says the BF16 version runs on two H200 GPUs where the base model needs four, and that the FP8 version fits on a single H200. The visible part of the card gives the download step and no run commands, so follow the card's quick start for serving.

• Python with pip
• GPU memory for the format you choose, from 40.5 GB to 122.3 GB of files
• vLLM for serving, as the card describes

1. Install the Hugging Face download tool.
2. Pick the BF16, FP8 or NVFP4 version.
3. Download it and serve it with vLLM, following the card.

pip install -U huggingface_hub
hf download MultiverseComputingCAI/Comet_60B_A12B_BF16

How to use it: Send text, image or video requests to the served model and turn reasoning on or off, as the card describes. For tool calling, use the same tool parser as the base model. One card covers all three formats and describes the BF16 one by default.

Title: Comet 60B against its base model
Property | Nemotron 3.5 Super VL | Comet 60B
Total parameters | 124.5B | 61.1B
Active per token | 12.8B | 12.3B
Routed experts per layer | 512 | 256

Example: You serve the BF16 version on two H200 GPUs and send it a photo of a receipt with a request to list the items. The model reads the image and returns the list as text. On the same four GPUs, the card says it produces 20 to 23 percent more output tokens per second than the original on NVIDIA's chat and agent traces.

For newcomers and experts: If you are new, this is a large model that was shrunk so it needs fewer GPUs. You need server hardware, so try a hosted version first if you only want to see what it does.

If you know the field, 22 of 256 routed experts plus one shared expert are active in each mixture-of-experts layer, down from 22 of 512 in the base.

Text, image or video goes in
The compressed 61.1B model routes each token
About 12B parameters are active
You get text, a reasoning trace or a tool call

Good to know: The card ships three formats of the same model. The smaller ones target newer NVIDIA GPUs.

Title: Checkpoint size by format, GB
BF16: 122.3
FP8: 66.3
NVFP4: 40.5

• License: OpenMDW 1.1, and the card says it is ready for commercial use under those terms
• Cost to run: none named, and the card sizes it in H200 GPUs
• Data it reaches: the model files from Hugging Face, and the text, images and video you send it
• Not for: a single small GPU, or anything that needs the original model's exact weights

On Hugging Face, 13 November 2026

• Task: image text to text
• Library: transformers
• Parameters: 61.1B
• Weights: about 122 GB in BF16; about 30.6 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 817
• Likes: 16
• License: openmdw-1.1
• Languages: en
• Quantized versions: 3
• Fine-tunes: 3
• Tags: transformers, safetensors, nemotron_h_omni, image-text-to-text, conversational

Links

• Model: https://huggingface.co/MultiverseComputingCAI/Comet_60B_A12B_BF16
• Files: https://huggingface.co/MultiverseComputingCAI/Comet_60B_A12B_BF16/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download MultiverseComputingCAI/Comet_60B_A12B_BF16

Then follow the usage in its model card. Nothing in this kit runs by itself.