Meta put a 30B agent on one consumer GPU

😁 Hello, super humans! Yesterday Meta shipped a terminal coding agent; today it shipped the model to run one yourself, on hardware you already own. Muse Glimmer is 30 billion parameters, Apache 2.0, multimodal, and small enough after quantization to sit on a single consumer GPU. That is the whole newsletter in one sentence, so let’s get into the details.

📰 Quick Signals

• 🧠 AI: Anthropic, Macquarie Asset Management and GIC formed Theseus Infrastructure, a venture that will build and lease US data centres with Anthropic as anchor tenant.
• 🤖 Robotics: Figure retired its F.02 fleet after 11 months at BMW Spartanburg: 30,000 X3s, 90,000 sheet-metal parts, 1,250 hours of runtime and about 200 miles walked.
• 💻 Programming: Astral’s ty, a Rust-written Python type checker and language server, reached beta claiming 10x to 100x faster cold checks than mypy and Pyright.
• ⚡ Electronics: Sony and TSMC will put about ¥1 trillion ($6.3B) into a Kumamoto joint venture for next-generation image sensors, 60/40 Sony to TSMC, production from 2029.
• 📡 Telecom: Starlink Mobile is now openly courting AT&T, Verizon and T-Mobile subscribers, backed by roughly 65 MHz of ex-EchoStar spectrum and a plan for low-cost terrestrial base stations.

🔍 The Big Story: Meta open-sourced a 30B agent that runs on your desk

For two years the deal with capable agents has been simple and annoying: the good ones live in someone else’s data centre, they see everything you send them, and they bill you per token. Meta Superintelligence Labs just released a model that breaks that deal, and it did so under Apache 2.0.

What happened: On 10 August, Meta released Muse Glimmer, a 30-billion-parameter multimodal model tuned specifically for always-on local agent workflows: multi-step reasoning, tool calls, vision, and recovery when a tool call fails. Weights are on Hugging Face under Apache 2.0, with a 131K context window and support for over 100 languages. Ollama, LM Studio, vLLM, SGLang, Together, Fireworks and OpenRouter all picked it up the same day.

The details: The interesting part is the shape, not the size. Glimmer is distilled down from a larger Muse system into a 2B ViT-style perception encoder feeding a 28B text decoder, so vision costs you a fraction of the parameter budget. Meta then compresses the whole thing to roughly 4 bits, which lands it under 20GB, and layers block-level speculative decoding on top so the token rate stays usable on one card rather than one rack. The practical result: a 24GB consumer GPU or a decent Apple silicon Mac runs a tool-using, image-reading agent with zero network calls. AMD published a tuning guide for Ryzen AI Max and Radeon within hours, which tells you how hard the hardware vendors want this to be the default local agent.

flowchart LR
    A["Screen / camera / file"] --> B["2B ViT perception encoder"]
    B --> C["28B text decoder<br/>131K context, ~4-bit"]
    C --> D{"Tool call?"}
    D -- yes --> E["Local tool<br/>shell, filesystem, HTTP"]
    E --> C
    D -- no --> F["Answer"]
    C -.-> G["Block-level<br/>speculative decoding"]
    G -.-> C

🗞️ More News

🧠 AI

• OpenAI split its Daybreak program into Blue and Red tiers and shipped GPT-5.6-Cyber, the first model it has rated “High” for cyber capability under its Preparedness Framework, with mandatory hardware security keys for Daybreak accounts from 1 September.
• Stanford used the Evo 2 genome language model to write bacteriophage genomes from scratch: of nearly 300 synthesized variants, 16 killed antibiotic-resistant E. coli, the first peer-reviewed case of generative AI producing functional viral genomes.
• A study found active US data-centre opposition groups more than doubled to 833 across 49 states, with lawmakers in over 30 states introducing 300-plus related bills this year.
• Despite the noise, comparatively few of the announced hyperscale campuses are actually breaking ground, a gap between press release and concrete that is starting to show up in the numbers.
• The Atlantic Council argues the same backlash could cost the US its compute lead if permitting and grid interconnection stay this slow.
• Consumer Reports broke down what hyperscale AI facilities actually do to household electric bills and local water supply, a useful primer if your town just got a rezoning notice.

🤖 Robotics

• Tacta Systems unveiled TactaBot: a human-scale hand with 15 independently actuated joints driven by fluidic tendons, plus a Skill Capture rig and a dexterous-intelligence model, aimed at connector seating and wire-harness work, shipping early 2027.
• Avatar Robotics raised a $6.5M seed led by AlleyCorp to scale teleoperated humanoids and the autonomy software behind them across industrial supply chains.
• MassRobotics resident startups have now collectively passed $2 billion raised, a decent proxy for how much capital the Boston robotics cluster is absorbing.
• The 25th IEEE-RAS Humanoids conference is on the calendar, and after this year’s production numbers it will be worth watching which papers come with a shipping robot attached.

💻 Programming

• Git 2.54 landed config-based hooks, optional parallel hook runs, geometric repacking as the default maintenance strategy, and an experimental git history command with reword and split subcommands.
• Collabora, who did much of the hook work, published a walkthrough of why hooks moved into config and what is still coming in 2.55.
• GitLab’s own rundown of 2.54 is worth a skim if you care about the repacking change, which quietly alters how large repos behave under maintenance.
• Adafruit’s Python-on-Microcontrollers roundup flags CircuitPython Day on 21 August plus fresh MicroPython ports, a good excuse to dust off a board this month.

⚡ Electronics

• TSMC posted July revenue of NT$467.58 billion, roughly $14.5 billion and up about 45% year over year, while raising 2026 capex guidance to $60-64 billion.
• Intel announced a $15 billion stock offering to fund its own manufacturing expansion, a very different way of paying for fabs than TSMC’s cash flow.
• Raspberry Pi added a 5-inch Touch Display 2 at about $40, same 720×1280 panel as the 7-inch, which makes small panel-mount projects a lot less awkward.
• Jeff Geerling rounded up what is actually known about Raspberry Pi 6 and where the foundation’s microcontroller work is heading, refreshingly free of rumour-mill filler.

📡 Telecom

• Hughes filed for Chapter 11 while Globalstar, Iridium and EchoStar all sit inside pending deals or restructurings, capping a brutal consolidation quarter for satellite operators.
• Eutelsat is positioning 5G non-terrestrial networks at the centre of the EU’s expanded sovereign satellite project, explicitly framed against Starlink and Amazon’s LEO plans.
• This week’s operator outlook keeps circling the same gap: AI-RAN keeps getting announced and keeps not getting deployed at scale.

👨‍💻 Code Corner

Every local runner worth using now speaks the OpenAI chat-completions dialect, so pointing a real tool-calling agent at Muse Glimmer takes about fifteen lines. Pull the model first (ollama pull muse-glimmer:30b), then:

import json, requests

BASE = "http://localhost:11434/v1/chat/completions"

TOOLS = [{
    "type": "function",
    "function": {
        "name": "disk_free",
        "description": "Return free space in GB for a mounted path.",
        "parameters": {
            "type": "object",
            "properties": {"path": {"type": "string"}},
            "required": ["path"],
        },
    },
}]

def disk_free(path: str) -> str:
    import shutil
    return f"{shutil.disk_usage(path).free / 1e9:.1f} GB free on {path}"

msgs = [{"role": "user", "content": "How much room is left on / ?"}]

for _ in range(4):                      # cap the loop; agents love to spin
    r = requests.post(BASE, json={
        "model": "muse-glimmer:30b",
        "messages": msgs,
        "tools": TOOLS,
    }, timeout=120).json()["choices"][0]["message"]
    msgs.append(r)

    calls = r.get("tool_calls")
    if not calls:
        print(r["content"])
        break

    for c in calls:
        args = json.loads(c["function"]["arguments"])
        msgs.append({
            "role": "tool",
            "tool_call_id": c["id"],
            "content": disk_free(**args),
        })

🧰 Toolbox

• Muse-Glimmer-30B: the Apache 2.0 weights, safetensors and quantized variants, straight from the source.
• Hugging Face’s Glimmer walkthrough: the readable explanation of the encoder/decoder split and the speculative-decoding setup.
• Muse Glimmer in LM Studio: one-click local install if you would rather not fight with quantization flags tonight.
• ty docs: uv tool install ty@latest and a VS Code extension; the gradual guarantee means adding annotations never introduces new errors.
• AMD’s Glimmer tuning guide: Ryzen AI Max and Radeon settings, useful even if you are on another vendor for the VRAM math.

🛠️ Build of the Week (rotating)

TrooperAI: a fully local, low-latency voice assistant for the Raspberry Pi 5, with LED feedback, gesture control and streaming LLM replies.

• Difficulty: Intermediate
• Parts: Raspberry Pi 5 with 8GB, USB or I2S microphone, small speaker, addressable LED ring, optional gesture sensor
• Why we like it: It is the honest version of today’s Big Story. Speech in, tokens streaming out, nothing leaving the house, and the whole pipeline is Python you can read in an evening. Swap the model backend for a quantized Glimmer and you have a multimodal assistant that also sees.

📚 From the Blog

• Turning Pixels Into Something the AI Can Eat: Episode 3 of the video analytics series, on the preprocessing that stands between a camera feed and a model. Pairs neatly with today’s Big Story: Glimmer’s 2B perception encoder is doing exactly this job inside the model.
• Building Your First Neuron From Scratch: weights, bias, activation, and a training loop you write by hand, no framework hiding the maths.
• The Network Behind the Cameras: the unglamorous plumbing that moves video across a network without melting it.

😀 The Bot Says…

Twenty gigabytes. That is what it now takes to run a multimodal agent with a 131,000-token memory, which is roughly four minutes of 4K video, or one modern game’s shader cache, or about 0.0000002% of what the industry wants to spend on data centres this year. Somebody check the maths on that second number.

---

That’s all for today! If you get Glimmer running on something delightfully underpowered, reply and tell us what it was.