Intel Enables Day-One Support for Meta’s 816-Billion-Parameter Muse Spark Open AI Model

Intel has announced day-one support for Meta’s Muse Spark Open AI model across Intel Xeon processors and its upcoming Intel GPU D-series data center accelerators. The announcement highlights Intel’s efforts to make large, advanced AI models easier to deploy on its hardware through low-precision computing and model quantization.

Muse Spark Open contains 816 billion parameters, making it a demanding workload for data center infrastructure. Running models at this scale requires substantial memory capacity, efficient computing resources, and software that can handle inference without excessive hardware costs.

Intel says it has tested Muse Spark Open on its upcoming GPU D-series accelerators and enabled support on Xeon processors. The company is also working with open-source AI software projects, including vLLM and SGLang, to help developers run quantized versions of the model.

What Is Meta’s Muse Spark Open?

Muse Spark Open is an open-weight AI model from Meta designed to support coding, multimodal understanding, and agentic workflows.

According to the supplied announcement, the model is optimized for coding tasks such as generating code, debugging programs, and understanding large software repositories. Its reported one-million-token context window is designed to help it process extensive codebases, including projects with complex dependencies and thousands of files.

The model also supports multimodal tasks involving images, audio, video, and documents. For agentic applications, it can be used in workflows where an AI system plans tasks, uses tools, observes results, and adjusts its next steps.

These capabilities could be useful for developers building AI coding assistants, automated research workflows, and systems that interact with web pages or computer interfaces.

However, deploying a model with 816 billion parameters is a significant infrastructure challenge. Even when weights are stored using lower-precision formats, organizations need enough memory and computing capacity to run inference efficiently.

How Intel Is Making Muse Spark Open Easier to Run

Intel is using model quantization to reduce the memory requirements of Muse Spark Open while taking advantage of specialized hardware capabilities.

Quantization reduces the precision used to represent model weights and other numerical values. Instead of storing all weights in a higher-precision format, a model can use lower-bit representations that require less memory and may improve inference efficiency on compatible hardware.

Intel has prepared two quantized variants for different hardware platforms:

• MXFP4: A low-precision format intended for Intel GPU D-series accelerators.
• INT4 weight-only quantization: A compressed-weight approach designed for Intel Xeon processors.

The objective is to make the model more practical to run without unnecessarily sacrificing the accuracy of its outputs.

Intel says it generated these variants from Muse Spark Open’s original BF16 weights using vLLM’s llm-compressor tool and the AutoRound quantization algorithm.

AutoRound optimizes rounding and clipping parameters across model layers. According to Intel, this process is intended to preserve important model capabilities while reducing the number of bits used to represent weights.

The effectiveness of quantization can vary by workload, so developers still need to evaluate output quality and performance for their specific applications.

Intel GPU D-Series Targets Large AI Models

Intel’s upcoming GPU D-series is designed to support demanding AI inference workloads, including large models and agentic AI systems.

Intel lists the following hardware capabilities for the platform:

• 32 Xe3P cores.
• 256 Intel XMX engines.
• Hardware acceleration for multiple data types, including MXFP4.
• 160 GB of LPDDR5x memory per GPU, with configurations offering up to 480 GB.
• A 350-watt, air-cooled PCIe form factor.

The combination of memory capacity and low-precision computing is particularly relevant for large-model inference. Models with hundreds of billions of parameters can require substantial memory simply to hold their weights, before accounting for runtime overhead and the memory needed to process incoming requests.

Intel says Muse Spark Open has been tested on four Intel GPU D-series GPUs, each providing 160 GB of memory. Together, the four accelerators offer 640 GB of GPU memory.

The company says this configuration can run the 816-billion-parameter model using its quantized MXFP4 variant.

This could give businesses an additional hardware option when evaluating large AI models. However, actual performance and memory requirements depend on the quantization format, context length, workload, and serving configuration.

Intel’s air-cooled PCIe design is also intended to simplify installation in conventional data center environments compared with deployments that require more specialized cooling infrastructure.

Running Muse Spark Open on Intel Xeon Processors

Intel is also enabling Muse Spark Open inference on Xeon server processors, offering an alternative to GPU-based deployments.

The CPU implementation uses INT4 weight-only quantization, which reduces the memory footprint of model weights. Intel Xeon processors can also use Intel Advanced Matrix Extensions (AMX) to accelerate supported AI matrix operations.

This approach may be useful for organizations that want to experiment with offline inference or deploy models on existing CPU-based server infrastructure.

Running inference on CPUs can offer deployment flexibility, particularly where organizations already have substantial Xeon capacity and want to avoid introducing additional accelerator hardware. The trade-off is that performance depends on the server configuration, memory bandwidth, workload, and quantized model implementation.

Intel says its day-one support includes instructions for running Muse Spark Open on Xeon processors using SGLang. The company is also working with the vLLM community to provide additional Xeon deployment recipes.

For businesses considering private AI deployments, these options could help them assess whether CPU-based inference meets their performance and cost requirements.

Open-Source Software Plays a Key Role

Hardware alone is not enough to deploy a model of this size. The software stack must efficiently load model weights, schedule inference requests, manage memory, and support the operations required by AI applications.

Intel is working with two open-source inference frameworks: vLLM and SGLang.

vLLM Support

Intel says upstream support for compressed tensors, including MXFP4, and GPTQ-based INT4 weight-only quantization in vLLM enables optimized execution on supported hardware.

The framework provides inference capabilities such as continuous batching and PagedAttention. These techniques help manage multiple requests and the memory used by their attention operations.

This is important for production environments where a model may need to serve many requests rather than process a single prompt at a time.

SGLang Support

Intel is also contributing to support for low-bit inference and Intel XPU-optimized kernels in SGLang.

These integrations are intended to improve inference throughput and support complex, multi-turn agentic workflows. Such workloads may involve repeated model calls, tool use, and intermediate results rather than a single question-and-answer interaction.

By working with established open-source frameworks, Intel aims to make deployment more accessible to developers who want to use familiar tools instead of building an entirely separate inference system.

Why This Matters for Enterprise AI

The cost of running large AI models is becoming an important consideration for organizations moving from experimentation to production.

Businesses must evaluate more than a model’s capabilities. They also need to consider hardware costs, memory capacity, electricity consumption, response times, software compatibility, and the number of users or requests a system can support.

Intel’s approach provides two deployment paths: quantized inference on its upcoming GPU D-series and INT4 weight-only inference on Xeon processors.

These options could be relevant to organizations exploring AI coding assistants, private enterprise AI systems, and agentic applications that need to process large amounts of context.

The announcement also demonstrates the importance of software optimization. Quantization, hardware acceleration, and inference frameworks must work together to make very large models practical to operate.

Still, day-one support does not automatically mean that a model will perform equally well across every workload. Businesses should benchmark inference speed, memory use, output quality, and operating costs before choosing a deployment configuration.

Conclusion

Intel has announced day-one support for Meta’s 816-billion-parameter Muse Spark Open model on Xeon processors and its upcoming GPU D-series accelerators.

The company is using MXFP4 and INT4 quantization to reduce memory requirements while leveraging hardware acceleration and open-source inference frameworks such as vLLM and SGLang.

A four-GPU D-series configuration provides a combined 640 GB of memory, while Xeon processors offer another route for organizations evaluating CPU-based inference.

As businesses explore increasingly large AI models, Intel’s work highlights how hardware design, quantization, and software optimization can help expand deployment options. The practical benefits will ultimately depend on measured performance, output quality, and the requirements of each real-world workload.