Muse Spark 1.2 Self-Hosting vs the $1.25/M API: GPU Cost Checklist

The API price is the benchmark

You are deciding whether to self-host Muse Spark 1.2 before the weights arrive. Mark Zuckerberg said Meta would make them available soon, without a date. The Meta Model API price starts at $1.25 per million input tokens. Self-hosting wins only when total serving cost divided by tokens served is below that price. Muse Spark 1.2 shipped on August 5 with a one-million-token context window. Meta launched Muse Spark in April 2026 after retiring the Llama model family, as part of a proprietary approach. The open-weight pledge changes that direction, but the production decision still starts with arithmetic. Meta launched Muse Code, a beta terminal coding agent built on Muse Spark 1.2. Use it as one workload to test, not the only one.

Meta introduced Muse Glimmer, a 30-billion-parameter open-weight model licensed under Apache 2.0. It is already available on Hugging Face. Use Glimmer as a license and distribution reference, not a substitute for Muse Spark 1.2.

The checklist is a cost model

Run the checklist before sizing hardware. Each item should be answerable quickly, and each answer should feed a dollar-per-token estimate. Keep the answers concrete enough to put into a spreadsheet. Treat it as a guardrail and decision gate: it asks whether the serving stack can carry your workload at a defensible price. The list separates model capability from serving-stack economics: if the stack cannot clear the API price, open-weight status does not fix the profit line.

• Confirm the license permits commercial self-hosting and redistribution.
• Record the parameter count.
• Record the context length.
• Record the modality mix you plan to serve.
• Set the concurrency target.
• Compute KV-cache memory for the full context at your planned batch size and concurrency.
• Estimate GPU count from memory pressure rather than parameter count alone.
• Choose the production batch size.
• Measure tokens per second at that batch size.
• Compare dollars per served token with the API price.

License terms come first because a weights release may still carry restrictions that block deployment. Context and KV-cache checks matter because long-context serving is memory-bound, and memory turns a model into a GPU count. Throughput and cost checks force the comparison into the same unit as the API price: dollars per token. The order matters: a license failure stops the project, a memory failure changes hardware, and a throughput failure changes batch size. A failed item should force a change in the plan, not a note in the appendix.

Run the numbers before the weights land

Start with the workload, not the model card. List request rate, average input length, average output length, modality mix, and concurrency target. Then estimate tokens served per hour. Keep input and output separate in the estimate. Use the same token unit for both sides of the comparison. Cover the input side first, then add output, storage, and ops. If the workload is mostly long documents, input dominates. If it is mostly short prompts, output can change the answer even when input cost looks close.

Build the self-hosted cost from the serving stack, not from a single GPU price. Include GPU-hours, power, cooling, storage, network, labor, maintenance, and idle time from low utilization. Divide total serving cost by tokens actually served. A high-throughput batch can lower cost per token, but it can raise latency and memory pressure. A low-throughput batch can keep latency down, but it can leave GPUs underused. The batch-size choice is the main lever between utilization and latency. Record the chosen batch size in the checklist, because it changes KV-cache memory, throughput, and cost per token.

If the estimate is above the API price, use the API. If it is below, self-host only after the license, memory, and throughput checks pass.