Catch up on what's trending in open source, October 19
This week's Model Mondays edition highlights three Hugging Face models newly available in Microsoft Foundry, giving developers more open-weight options for enterprise coding and agentic work: Meta's Muse Spark Open, NVIDIA's Nemotron 3.5 Super VL, and Reflection's Beam 1.0.
Models of the week
Meta: Muse-Spark-Open-816B-A42B-NVFP4
Model Specs
- Parameters / size: 816B total / 42B active; Mixture of Experts, which activates a subset of parameters for each token; NVIDIA's 4-bit floating-point format (NVFP4).
- Context length: 1,048,576 tokens in the Foundry deployment.
- Primary task: Multimodal reasoning, multi-step reasoning, coding, and agentic task completion.
Why it's interesting
- Published agent and coding evaluations: Meta reports scores of 89.2 on MCP-Atlas, which evaluates tool use through the Model Context Protocol (MCP), and 76.4 on Terminal-Bench 2.1, using the Terminus 2 agent. These are Muse Spark Open results at xhigh reasoning effort; the benchmark table does not identify them as NVFP4-specific measurements.
- Adjust reasoning effort to the task: The model supports planning, sequential tool calls, and recovery from tool failures. Its reasoning_effort setting offers low, medium, high, and xhigh; Meta recommends the higher settings for complex coding and agentic work. See the model card.
- Bring visual and conversational evidence into the same workflow: Muse Spark is natively multimodal. It can interpret screenshots, documents, and recordings alongside text. For developers building a product support agent, that opens up end-to-end agentic task completion.
Hardware and deployment configuration:
Muse Spark's NVFP4 deployment on Azure Foundry has a 1M-context deployment template on NVIDIA H200, intended for long-context reasoning, coding, agentic tasks, and multimodal workloads. Eight GPUs jointly serve one model instance, with both the model tensors and its experts distributed across them.
|
Configuration |
H200 template |
|---|---|
|
Best for |
Long-context coding and reasoning, multimodal analysis, and extended tool-using workflows |
|
Hardware per model instance |
8 × NVIDIA H200, 141 GB GPU memory each |
|
Azure instance type |
Standard_ND96isr_H200_v5 |
|
Model weights |
NVFP4 |
|
Maximum context |
1,048,576 tokens |
|
Inputs / output |
Text, images, audio, and video / text |
|
Agent capabilities |
Tool calling and reasoning; per-request effort of low, medium, high, or xhigh (default) |
|
Request timeout |
5 minutes |
This preset retains the model's full native context window, allowing prompts, media, tool results, and generated output to share a single extended context.
NVIDIA: NVIDIA-Nemotron-3.5-Super-VL-120B-A12B-BF16
Model Specs
- Parameters / size: 120B total / 12B active; hybrid MoE architecture; Brain Floating Point 16 (BF16) weights.
- Context length: Up to 1M tokens natively; 524,288 tokens in the current Foundry deployment presets.
- Primary task: Vision-language reasoning, document and video understanding, coding, and tool use; text, image, and video input, with text output.
Why it's interesting
- Visual understanding alongside reasoning. A vision encoder connects images and video frames to a language backbone combining Mamba-2 state-space layers, attention, and sparse experts. Developers can use the model to interpret document layouts, charts, and application screens in the same workflow as textual instructions.
- Reasoning that can be switched on or off. The model supports configurable thinking, giving applications a way to distinguish straightforward extraction from questions that require several reasoning steps.
- Document and chart evaluation results. NVIDIA reports 62.82 on MMLongBench-Doc, 65.08 on OCR-Reasoning (optical character recognition with reasoning), and 80.82 on CharXiv reasoning, which tests understanding of scientific charts. These are publisher-reported results for the BF16 model; see the benchmark table and evaluation methodology.
Hardware and deployment configurations:
Nemotron's BF16 deployment on Azure Foundry is available on NVIDIA A100 and H100 templates, both configured for 512K context. Each uses four GPUs per model instance. The main configuration difference is the attention cache, which stores information from earlier tokens: the A100 preset retains BF16 precision, while the H100 preset uses 8-bit floating point (FP8) to reduce cache memory.
|
Configuration |
A100 template |
H100 template |
|---|---|---|
|
Best for |
Document, chart, and application-screen understanding when preserving BF16 cache precision matters |
The same visual and reasoning tasks when faster generation and shorter waits on long prompts matter |
|
Hardware per model instance |
4 × NVIDIA A100, 80 GB GPU memory each |
4 × NVIDIA H100, 80 GB GPU memory each |
|
Azure instance type |
Standard_ND96amsr_A100_v4 |
Standard_ND96isr_H100_v5 |
|
Model weights |
BF16 |
BF16 |
|
Attention-cache precision |
BF16 |
FP8 |
|
Maximum context |
524,288 tokens |
524,288 tokens |
|
Active sequence cap per instance |
32 |
32 |
|
Request timeout |
90 seconds |
90 seconds |
Choose A100 for cache precision; choose H100 for response speed. The template descriptions position H100 as the faster option for generation and long-prompt processing, using a lower-precision cache while keeping the model weights in BF16. Both presets offer the same context window and active sequence cap, so this choice is about cache precision and performance rather than additional context capacity.
Both templates enable tool calling, reasoning, and reuse of cached prompt prefixes. They accept text plus up to one image and one video per prompt; video sampling is configured at two frames per second, with a maximum of 256 sampled frames. Both also enable speculative decoding with three proposed tokens per step, using the model's ability to predict multiple upcoming tokens to accelerate generation.
Reflection: Beam-1.0-501B-A23B
Model Specs
- Parameters / size: 501.3B total / 23.4B active; sparse MoE; available with BF16, FP8, and NVFP4 weights.
- Context length: 1,048,576 tokens natively; 524,288 tokens in the Foundry BF16 preset and 262,144 tokens in the FP8 and NVFP4 presets.
- Primary task: Text generation for software engineering, reasoning, and agentic tool use; developed predominantly for English.
Why it's interesting
- Built around software engineering workflows. Beam is designed to work with repositories, terminal environments, and tools across extended tasks. Its text-only interface fits coding agent workflows.
- Reasoning efficiency is an explicit training objective. Reflection describes training with a length penalty that discourages unnecessary generated tokens while rewarding successful solutions. Its launch post explains the trade-off between reasoning effort and task performance.
- BF16 coding and tool-use results. The release model card reports 81.6% on SWE-bench Verified, 80.1% on Terminal Bench v2.1, and 80.8% on MCP Atlas for BF16. These cover repository issue resolution, terminal tasks, and tool use respectively.
Hardware and deployment configurations:
The same Beam model is available in three weight precisions: BF16, FP8, and NVFP4. All retain the same parameter count and text, reasoning, and tool-calling capabilities. The lower-precision releases reduce the memory needed for weights, opening up A100 and H100 deployment options.
|
Weight precision |
Hardware per model instance |
Default Azure instance type |
Maximum context |
Best for |
|---|---|---|---|---|
|
BF16 |
8 × NVIDIA H200, 141 GB GPU memory each |
Standard_ND96isr_H200_v5 |
524,288 tokens (512K) |
Long-context reasoning and agentic tool use with full-precision weights |
|
FP8 |
8 × NVIDIA A100, 80 GB GPU memory each |
Standard_ND96amsr_A100_v4 |
262,144 tokens (256K) |
Reasoning and tool use on A100 while retaining higher weight precision than NVFP4 |
|
FP8 |
8 × NVIDIA H100, 80 GB GPU memory each |
Standard_ND96isr_H100_v5 |
262,144 tokens (256K) |
The same FP8 workloads when H100 capacity or measured workload performance fits better |
|
NVFP4 |
4 × NVIDIA A100, 80 GB GPU memory each |
Standard_ND96amsr_A100_v4 |
262,144 tokens (256K) |
Reasoning and tool use with a smaller GPU allocation on A100 |
|
NVFP4 |
4 × NVIDIA H100, 80 GB GPU memory each |
Standard_ND96isr_H100_v5 |
262,144 tokens (256K) |
The same four-GPU option when H100 capacity or measured workload performance fits better |
All five templates use an FP8 attention cache, support tool calling with automatic tool selection and reasoning, enable reuse of cached prompt prefixes and processing long prompts in chunks, and set a 90-second request timeout.
Getting started
You can deploy these Hugging Face models in Microsoft Foundry by browsing the Hugging Face collection in the Foundry model catalog and selecting a managed endpoint deployment.