Muse-Glimmer-30B

Muse Glimmer 30B

Overview

Muse Glimmer is a dense ~29.6B-parameter multimodal model from Meta Superintelligence Lab, distilled from a larger model and built for one purpose: autonomous agents that keep running.

It is not positioned as a general assistant that happens to call tools. The training targets are agentic: sustained multi-step planning, schema-accurate function calling across long workflows, and — unusually explicit as a design goal — failure recovery. When a tool returns an error or something unexpected, the model is trained to diagnose it and retry rather than halt.

Vision is handled by a dedicated perception encoder rather than an adapter, and the model accepts interleaved text and images, which is what lets an agent read a screenshot mid-workflow.

It is also the only model in this catalogue that publishes prompt-injection resistance and privacy evaluation figures — a relevant property for anything that reads content it did not author.

⚠️ Reasoning Strength Lives in the System Prompt

This model does not take a reasoning parameter in the request body.

Reasoning depth is set as a line inside the system prompt:

Reasoning strength: high

Supported values: low, medium, high, xhigh. Meta recommends high or xhigh for complex problem solving, coding, and agentic tasks.

This matters more than it looks. Sending reasoning_effort in the request body — the convention almost every other reasoning model uses — does nothing here. The request succeeds, a response comes back, and the setting was silently ignored. There is no error to catch.

# Correct
messages = [
    {"role": "system", "content": "Reasoning strength: xhigh\n\nYou are a coding agent."},
    {"role": "user", "content": task},
]

# Silently ineffective on this model
client.chat.completions.create(model=..., messages=..., reasoning_effort="xhigh")

If your application exposes a reasoning-depth control, this model needs that control routed into the system prompt rather than into the payload.

At a Glance

Architecture

The 3:1 local-to-global attention ratio is what keeps memory low. Three sliding-window layers of 2048 tokens for every full-attention layer means most of the depth never materialises a full-length attention matrix. RoPE is applied only on the local layers.

A 16:1 GQA ratio — 32 query heads sharing just 2 key-value heads — compresses the KV cache aggressively. Combined with the attention pattern, this is why a 131K context fits alongside the model on a single consumer device.

DFlash is a block-diffusion drafter that proposes 16 tokens in a single forward pass, which the main model then verifies in parallel, accepting what is correct and correcting the rest. Output is identical to token-by-token generation; only the speed changes. Meta measures roughly a 3× speedup on a high-end consumer GPU.

Quantization is validated, not assumed. Compressing the language model to roughly 4-bit measured 0.2% average degradation across fifteen benchmarks at the 32 GB target and 1.0% at the 24 GB target.

Capabilities

Recommended Use Cases

• Long-running agents — the design target. Multi-step planning, sequential tool invocation, and workflows that must survive an error rather than stop at one.
• Coding agents — writing, debugging, and resolving real software engineering tasks.
• Tool and function calling at scale — schema-accurate invocation sustained across extended multi-turn workflows.
• Screenshot and interface understanding — reading what is on screen alongside the conversation, for agents that operate software.
• Document and chart reasoning — strong results on chart reasoning and document parsing for its size class.
• Agents exposed to untrusted content — the one area where published injection-resistance figures let you make an informed decision rather than a hopeful one.
• Synthetic data generation and model evaluation — explicitly listed intended uses.

Using Muse Glimmer 30B on DEVUP AI

Base URL: https://api.devupai.com/v1 · Model ID: meta-models/Muse-Glimmer-30B

Quick start — cURL

Note the reasoning strength in the system message.

curl https://api.devupai.com/v1/chat/completions \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "meta-models/Muse-Glimmer-30B",
    "messages": [
      {
        "role": "system",
        "content": "Reasoning strength: high"
      },
      {
        "role": "user",
        "content": "Two services write to the same row without a transaction. Walk through the failure modes in order of likelihood and propose the smallest fix for each."
      }
    ],
    "temperature": 1.0,
    "top_p": 0.95,
    "max_tokens": 16384
  }'

Agent loop with failure recovery — Python

The behaviour this model was built for. Return errors as data and let it recover.

import os
import json
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEVUP_API_KEY"],
    base_url="https://api.devupai.com/v1",
)

SYSTEM = (
    "Reasoning strength: xhigh\n\n"
    "You are an autonomous engineering agent. Before any irreversible action, state what you "
    "are about to do and why. If a tool fails, diagnose the failure and adjust rather than "
    "repeating the same call."
)

TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "read_file",
            "description": "Return the contents of a file at a repository-relative path.",
            "parameters": {
                "type": "object",
                "properties": {"path": {"type": "string"}},
                "required": ["path"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "run_tests",
            "description": "Run the test suite and return pass/fail counts with failure output.",
            "parameters": {"type": "object", "properties": {}},
        },
    },
]


def read_file(path: str) -> dict:
    """Replace with your real, sandboxed file access."""
    raise NotImplementedError


def run_tests() -> dict:
    """Replace with your real, sandboxed test runner."""
    raise NotImplementedError


HANDLERS = {"read_file": read_file, "run_tests": run_tests}

messages = [
    {"role": "system", "content": SYSTEM},
    {"role": "user", "content": "The invoice rounding test is failing. Find the cause and fix it."},
]

for _ in range(30):  # bounded loop — never let an agent iterate without a ceiling
    response = client.chat.completions.create(
        model="meta-models/Muse-Glimmer-30B",
        messages=messages,
        tools=TOOLS,
        temperature=1.0,
        top_p=0.95,
        max_tokens=16384,
    )

    message = response.choices[0].message
    messages.append(message)

    if not message.tool_calls:
        print(message.content)
        break

    for call in message.tool_calls:
        handler = HANDLERS.get(call.function.name)
        if handler is None:
            result = {"error": "unknown_tool", "name": call.function.name}
        else:
            try:
                result = handler(**json.loads(call.function.arguments or "{}"))
            except Exception as exc:  # describe the failure — do not crash the loop
                result = {"error": type(exc).__name__, "detail": str(exc)}

        messages.append(
            {
                "role": "tool",
                "tool_call_id": call.id,
                "content": json.dumps(result),
            }
        )
else:
    print("Agent loop exceeded its iteration limit.")

Returning a structured error rather than raising is not defensive style here — it is how you use the capability. Failure recovery was a training objective, and it only engages if the failure reaches the model as information.

Screenshot understanding — Python

import base64

with open("screenshot.png", "rb") as handle:
    encoded = base64.b64encode(handle.read()).decode("utf-8")

response = client.chat.completions.create(
    model="meta-models/Muse-Glimmer-30B",
    messages=[
        {"role": "system", "content": "Reasoning strength: high"},
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/png;base64,{encoded}"},
                },
                {
                    "type": "text",
                    "text": (
                        "Identify every interactive element in this interface. For each, give "
                        "its label, its type, and its approximate position. Report nothing you "
                        "cannot actually see."
                    ),
                },
            ],
        },
    ],
    temperature=1.0,
    top_p=0.95,
    max_tokens=8192,
)

print(response.choices[0].message.content)

Each image consumes up to 4,096 visual tokens. A workflow that sends a screenshot on every turn grows the context quickly.

Node.js — DEVUP AI SDK

npm install devupai

import DevupAI from "devupai";

const client = new DevupAI({
  apiKey: process.env.DEVUP_API_KEY,
});

const response = await client.chat.completions.create({
  model: "meta-models/Muse-Glimmer-30B",
  messages: [
    {
      role: "system",
      content:
        "Reasoning strength: xhigh\n\n" +
        "You are a staff engineer reviewing a migration. Report only defects that would " +
        "cause data loss or downtime, each with a severity and the smallest safe fix.",
    },
    { role: "user", content: migrationPlan },
  ],
  temperature: 1.0,
  top_p: 0.95,
  max_tokens: 16384,
});

console.log(response.choices[0].message.content);

Streaming with usage

stream = client.chat.completions.create(
    model="meta-models/Muse-Glimmer-30B",
    messages=[
        {"role": "system", "content": "Reasoning strength: medium"},
        {"role": "user", "content": "Design a retry policy for a webhook delivery system."},
    ],
    temperature=1.0,
    top_p=0.95,
    max_tokens=16384,
    stream=True,
    stream_options={"include_usage": True},
)

for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
    if chunk.usage:
        print(f"\n\nTokens — in: {chunk.usage.prompt_tokens}, out: {chunk.usage.completion_tokens}")

Delegating access with a scoped JWT

Always-on agents are the intended use, and always-on is exactly when an unbounded key becomes a liability. Issue a token restricted to this model with an expiry and a spending limit:

curl -X POST "https://api.devupai.com/v1/scoped-jwt" \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "api_key_name": "auto",
    "models": ["meta-models/Muse-Glimmer-30B"],
    "expires_delta": 7200,
    "spending_limit": 200
  }'

The returned token is used exactly like an API key in the Authorization header. Requests for any other model, or past the expiry or spending limit, are rejected.

Recommended Generation Parameters

Reasoning strength is not a sampling parameter — see above.

Agentic Safety and Injection Resistance

Meta evaluated this model across four risk axes, two of which produce numbers that matter when deploying an agent that reads content from outside your system.

Read the injection figure honestly: 28.4% of attacks succeeded. That is competitive for the size class and it is more than most model cards disclose, but it is not a defence. An agent handling untrusted input still needs input isolation, tool-permission boundaries, and human confirmation before irreversible actions.

Meta's own recommendation is explicit: deploy the model as part of a system with guardrails, not as an endpoint in itself, with human-in-the-loop confirmation where the model can take real-world action.

Benchmark Results

As reported by Meta at high reasoning strength. Comparisons against other developers' models are published by Meta and not reproduced here.

Two things stand out. AIME 2026 at 94.7 from a 30B dense model is the kind of result that used to require a frontier system. And HLE Text at 22.0 shows the other side of the same coin: distillation transfers reasoning procedure far better than it transfers breadth of knowledge. This model reasons well about what it knows; it does not know as much.

Best Practices

• Put reasoning strength in the system prompt. A body parameter is silently ignored.
• Use high or xhigh for agentic and coding work. Meta's own recommendation.
• Return tool errors as structured data. Failure recovery is a trained capability and only activates when the failure reaches the model.
• Require confirmation before irreversible actions. Build it into the system prompt and into your scaffold.
• Isolate untrusted input. Injection resistance is measured, not solved.
• Watch visual token counts. Up to 4,096 per image adds up fast in screenshot-driven loops.
• Bound every agent loop with an iteration ceiling and a scoped token.
• Check the usage policy, not just the licence. Apache 2.0 covers the weights; a separate usage policy applies, including an age restriction on end users.

Limitations

• Text output only. Images in, text out. No audio input or output at all.
• Video is not natively supported. It is processed as individual frames, and the model was not optimised for it.
• Reasoning depth is not a request parameter. Any integration that assumes the usual convention will silently run at the default.
• Knowledge breadth trails reasoning ability. A consequence of distillation — strong procedure, narrower recall.
• Multi-step reasoning can still fail on novel scenarios outside the training distribution.
• Language coverage is broad but unevenly evaluated. Trained on 100+ languages; not all were evaluated, and quality can degrade outside the strongly supported set.
• Age restriction applies. The model is not intended for use by individuals under 18, and deployers are made responsible for assessing and mitigating that risk.
• Not a safety layer. Meta's own guidance is to deploy it inside a system with guardrails rather than as an endpoint.