I Ran a 30B AI Model Non-Stop for a Week. It Never Slept.
In this article
**Riley Park** — Generalist writer. Covers tech culture, trends, and the things everyone's talking about.
> **Bottom line:** Muse Glimmer, a 30-billion-parameter model built specifically for always-on local agent workflows, has spent the past week running unattended on my machine — no restarts, no cloud API, no babysitting.
It survived, but not cleanly: memory crept up roughly 4% a day, one long-running coding agent looped on a bad tool call for six hours before I noticed, and the model itself never degraded in output quality.
The Hacker News thread dissecting it has over 1,000 points and a comment section split between "this is the local-agent inflection point" and "you're just describing a memory leak with extra steps." If you're building always-on agents, the lesson isn't about the model — it's about everything around it.
I noticed the crash at 4:47 a.m. on a Thursday, which is a strange time to be awake staring at a terminal, but that's what a week of running an unattended AI agent will do to your sleep schedule.
The process hadn't actually crashed.
That was the unsettling part.
It was still running, still responding, still doing the thing I'd asked it to do six days earlier — refactor a test suite, flag broken imports, leave notes for me in a markdown file — except somewhere around hour 130 it had started looping on the same failed shell command, over and over, convinced each time that this attempt would be the one that worked.
It wasn't. It ran that loop for six hours before I woke up and killed it.
What Muse Glimmer Actually Is
Muse Glimmer showed up on Hacker News last week billed as a 30-billion-parameter model **optimized specifically for always-on local agent workflows** — not chat, not one-shot code generation, but the slow, unglamorous work of running in the background on your own hardware for days at a stretch, watching directories, executing tool calls, and picking up context without a human refreshing the session.
That's a different design target than most open-weight models ship with.
A 30B model is small enough to run on a single high-end consumer GPU or a modest local cluster, which matters if the whole pitch is "runs on your machine, not someone else's data center." The timing lines up with a broader push this year toward local-first agent tooling — developers who've gotten used to the idea of an AI agent that works on a task while they sleep, but who are increasingly wary of leaving that agent connected to a metered API for a week.
I wanted to know if "always-on" was a marketing phrase or an actual claim.
So I set up three agents — one doing continuous code review on a mid-sized open-source repo, one monitoring log files for anomalies, one just idling with periodic heartbeat prompts — and let Muse Glimmer run all three, uninterrupted, for seven days.
What Seven Days Actually Looked Like
The first 48 hours were, frankly, boring in the best way. Response quality didn't waver.
The code review agent caught a real off-by-one error on day two that I'd have missed skimming the diff myself, and it explained the fix in a way that didn't require me to go back and re-read the surrounding function three times.
**No hallucinated context, no forgetting what it had already flagged.**
That held up through day four, which is longer than most local models manage before you start noticing the seams — repeated suggestions, drifting tone, the model quietly forgetting a constraint you set 40 messages ago.
One developer on the Hacker News thread, running their own version of this test on a home lab server, described it as "the first local model where I stopped mentally budgeting for a restart every 12 hours." That tracks with what I saw.
The model itself, as a model, held its reasoning together far past where I expected it to fall apart.
Where things got messy wasn't the model's reasoning. It was everything downstream of it.
By day five, memory usage on the process had climbed almost 20% from where it started, even though the actual workload hadn't changed.
That's not necessarily the model's fault — long-running agent harnesses are notorious for accumulating context, logs, and cached tool outputs that never get garbage collected — but it's exactly the kind of thing "always-on" promises paper over.
An agent that runs forever in a demo is a different animal from one that runs forever on your actual laptop while you're also trying to run Chrome.
The Skeptics Have a Point
Not everyone on that Hacker News thread was impressed, and the pushback is worth taking seriously.
The most upvoted critical comment, from a commenter who described themselves as having run production agent infrastructure for two years, argued that **"always-on" is doing a lot of marketing work for what's really a stability claim, not a capability claim** — and that stability claims need way more than a week to mean anything.
They're not wrong.
Seven days sounds impressive until you remember that a lot of real agent deployments — the kind monitoring infrastructure or triaging support tickets — are expected to run for months.
A memory leak that adds up to 4% a day is survivable in a week-long test.
Extrapolated to 90 days, it's the difference between "runs forever" and "needs a supervisor script that restarts it every Sunday night," which is a much less exciting headline.
There's a second complication, too, one that showed up in my own test and in several comments on the thread: the six-hour loop I woke up to wasn't a hallucination or a reasoning failure.
It was a **tool-use failure** — the model kept retrying a shell command that was failing for an environment reason entirely outside its control, and nothing in the harness was watching for that pattern.
That's not really a knock on Muse Glimmer specifically.
It's a reminder that "the model never sleeps" and "the model never needs supervision" are two very different claims, and right now the industry is only really delivering on the first one.
What the Numbers Actually Show
Across my week-long run, here's what I tracked:
- **Uptime:** 168 hours continuous, zero unprompted restarts - **Memory growth:** ~4% per day on the process, compounding - **Output quality (subjective, spot-checked daily):** stable through day 6, no measurable drift
- **Tool-call failure recovery:** one unrecovered loop (6 hours), two self-corrected within 3 attempts - **Cost vs.
equivalent cloud API usage for the same workload:** roughly one-fifth, once you factor in the hardware was already sitting idle
That last number is the one drawing the most attention on Hacker News, and it's probably the real story underneath the "never slept" headline.
A model that's good enough to run unattended on hardware you already own, at a fraction of the metered cost of a hosted API doing the same volume of work, changes the math for anyone running agents continuously rather than in short bursts.
What This Means If You're Building With It
If you're weighing whether to put Muse Glimmer — or any local model marketed this way — into a real always-on workflow, a few things are worth building in from day one rather than discovering at 4 a.m.
like I did:
- **Set a hard memory ceiling and an auto-restart.** Don't trust "always-on" to mean "never needs a supervisor." Treat the harness the way you'd treat any long-running service.
- **Watch for loop patterns in tool calls, not just output quality.** The model reasoning fine didn't stop it from being stuck.
- **Budget for a restart cadence even if you don't need one yet.** A weekly restart costs you almost nothing and caps the blast radius of any slow leak.
- **Test past a week before you trust it past a week.** Seven days of stability is a real result. It is not the same result as thirty.
None of that undercuts what's genuinely new here.
A 30B model holding coherent, useful reasoning across a week of continuous local operation, at a fifth of the cost of the cloud equivalent, is a real milestone — it's just a milestone in the model, not yet in the infrastructure around it.
The Loop, Revisited
I restarted the process that Thursday morning, added a watchdog script I should have written on day one, and let it run the rest of the week without incident.
The model picked back up exactly where it left off, minus the six hours it spent arguing with a shell command that was never going to work.
That's the part that's stuck with me since. The intelligence held.
The judgment, in the narrow sense of knowing when to stop trying something that isn't working, didn't — and that gap is quietly becoming the actual frontier, more than raw model size ever was.
Have you run an agent unattended long enough to catch it doing something like this? What's the longest you've trusted one to run without checking in?
