How to reduce agent costs with Muse: tiers, caching, routing and local models

The biggest savings with Muse come from four moves: use cached input (about 88% cheaper than fresh input on the Meta Model API), send bulk work to the contributor tier or a local Muse Glimmer when the data isn't sensitive, let a cheap model do the work while a stronger one checks it, and cut the tools and context you send each turn. Then measure cost per finished task, because Meta's "25% fewer tokens" claim didn't hold on every job in independent testing.

Know the prices first

Meta Model API pricing per million tokens (Meta docs):

Tier	Input	Output	Cached input	Trains on your data
Standard	$1.25	$4.25	$0.15	No
Contributor	$0.10	$0.20	$0.002	Meta may

Extras: web search grounding is $2.50 per 1K queries, Muse Image is $0.01 per image, and voice transcription is $0.18 per audio hour. Rate limits are 3,000 RPM / 4M TPM on standard and 100 RPM / 3M TPM on contributor.

For the personal agent, plans are token budgets per week: Free (reported up to 100M), Power at $20/month for 500M, Max at $100/month for 3B. Muse Code runs $5, $15 or $50 a month.

1. Cache everything that repeats

Cached input on standard is $0.15/M against $1.25/M fresh. Agent loops resend the same system prompt, tool schemas and project context every turn, so a stable prefix pays off fast. Put the unchanging material first and the per-turn material last, and don't reorder tool definitions between calls.

2. Use the contributor tier where the data allows

The contributor tier is roughly 12x cheaper on input and 21x cheaper on output than standard, with the catch that Meta may train on what you send. That's fine for public code, game prototypes and experiments. It's not fine for client code, secrets or personal data. Muse Code uses the contributor model by default, per DataCamp.

The cost examples builders post are almost all contributor or free-tier runs:

• A Minecraft-style world for 10 cents with Spark 1.3.
• An auto-orbiting 3D city for about 20 yen on muse-spark-1.2-contributor.
• Spark 1.3 is also a free contributor model in OpenCode.

3. Cheap workers, one paid checker

The strongest pattern in the catalog is to split planning and checking from doing:

• ocodex fans out Spark 1.2 Contributor workers on decomposable coding work, with one paid supervisor auditing every claim.
• sol-loop has a GPT planner and a Muse Spark executor; the author says over 99% of tokens run on Muse.
• opencode-delegate and musecode keep Claude Code as the planner and push leaf tasks to free Spark 1.3 in opencode.

The expensive model writes short plans and reads short diffs. The cheap model burns the tokens.

4. Offload big reads

shunt-muse blocks full reads of large files in Claude Code and Codex and routes them to Muse Spark via muse exec. On a 617-line file the author measured about 4,800 tokens going out and 300 coming back. The pricey model never sees the whole file.

5. Run Glimmer locally for steady workloads

Muse Glimmer is Apache 2.0 and runs under 20GB at 4-bit. After the hardware, the marginal cost is electricity. Useful data points:

• AI/ML API had Glimmer and Spark 1.2 each write five self-playing games; Rohan Paul's recap says Glimmer delivered all five at about one-fifth of Spark's cost.
• Mozilla.ai ran Glimmer as a single llamafile to fix a real bug and open a draft PR, fully offline.
• Claude Code on local Glimmer wires it into Claude Code through LiteLLM.

Local isn't free if it fails your task. The GB10 negative result is a good reminder to test first.

6. Send fewer tools and less context

Tool schemas are paid input on every call. One multi-model pipeline found a tool-allowlist fix cut payloads from 161KB to 24KB. Context compaction helps too; the GenPark context compactor is one example.

7. Pick the effort level on purpose

Spark 1.3 has effort levels up to max. Higher effort costs more tokens but can pass on the first try, which is cheaper than three failed low-effort runs. Morgan Linton's VulcanBench run found serious issues at lower effort. Test both on your own tasks and compare cost per pass, not cost per call.

8. Measure cost per completed task

Meta claims Spark 1.3 uses about 25% fewer tokens than 1.2. DataCamp's three-task test saw two tasks improve and one refactor use 70% more, for a net 12% cost increase. Averages hide outliers. Tools like Maestro add token and cost telemetry to Muse Code, so you can see where spend goes.

Saving tokens on the personal agent

The consumer agent doesn't expose per-call pricing, but the same ideas apply to your weekly quota:

• Give a precise brief with a success condition, so it doesn't explore.
• Prefer a connector over browsing. Connector calls are structured; browsing burns tokens on page content.
• Make long jobs resumable, like the 77k-story census, so a cutoff doesn't waste completed work.
• Batch small errands into one scheduled task instead of many chats.

Quick checklist

1. Stable prompt prefix for caching.
2. Contributor tier or local Glimmer for non-sensitive bulk work.
3. Cheap worker, strong reviewer.
4. Trim tools and context.
5. Choose effort by cost per pass.
6. Log cost per task and review weekly.

See also evaluating agent builds and the tools and apps shelf.

Frequently asked questions

How much does the Muse Spark API cost?

On the standard tier, $1.25 per million input tokens, $4.25 per million output and $0.15 per million cached input. The contributor tier is $0.10, $0.20 and $0.002, but Meta may train on your data.

What is the cheapest way to use Muse Spark?

The contributor tier, or the free Spark 1.3 contributor model in OpenCode. Both suit public or throwaway work, not private code.

Is running Muse Glimmer locally cheaper than the API?

For steady, non-urgent workloads on hardware you already own, usually yes. It fits in under 20GB at 4-bit. Test it on your tasks first, since a failed local run isn't a saving.

Does Muse Spark 1.3 really use fewer tokens?

Meta says about 25% fewer than 1.2. DataCamp's test found it varies by task, with one refactor using 70% more and a net 12% cost increase over three tasks.