How Agent Operating Systems Handle Always-On AI

The pitch lands simply enough: describe what you want, iterate a bit, and walk away while the agent runs. Julian Goldie's recent community Q&A session on agent operating systems is structured around that premise—and it's worth taking seriously, not because it's unambiguously true, but because the gap between that premise and the actual practice is where the interesting questions live.

Goldie runs what he calls an Agent OS, a bundled system of automation pipelines built primarily around Hermes (his preferred agent interface, layered over Claude) and deployed on a continuous loop. The session is a community Q&A format—members submit questions, he answers them on camera—and the result is less a polished product demo than a working practitioner's notebook. That format has its own value. You get to watch someone troubleshoot in public.

The Goal vs. Schedule Distinction

The most clarifying technical point in the session is also the most underexplained in most AI automation content: the difference between a goal and a scheduled task.

When you give an agent a goal, it runs until the task is complete—then stops. That's fine for discrete jobs. But for genuinely continuous workflows—pull headlines, generate content ideas, draft social copy, repeat every 24 hours—the goal paradigm is the wrong tool entirely. You want a scheduled task, something that recurs on a cadence rather than terminating on completion.

Goldie explains it through his Hermes Auto Claude setup: "It's running 24/7. So every 24 hours it's going to look for the latest headlines, pull it in from Twitter, come up with ideas, and then we can come up with content for our website just by clicking this button."

Claude Code now has a native equivalent—scheduled tasks built directly into the platform—which is worth noting because it signals that the underlying infrastructure pattern Goldie describes isn't fringe. It's where the tooling is moving. ChatGPT has a scheduled tasks feature too. The ecosystem is converging on the same architecture from different directions.

What Goldie's session adds is the practitioner layer: how you actually configure these loops, what breaks, and what you do when you hit token walls.

Community Builds and the "Non-Technical" Claim

A recurring rhetorical move in the video is the community member showcase. Sheena built a LinkedIn follow-up agent. Lee shared a blueprint for an AI chief of staff—an agent that starts each day by briefing you on what matters, tracking project status, and keeping things from falling through the cracks. Goldie takes these community contributions seriously, using them as proof-of-concept for the "non-technical users can build this" thesis.

"You don't need to be technical anymore to build these sorts of automations," he says, pointing to the chief of staff example. "You can just go straight into it. Take a prompt like this and create it."

This is where honest scrutiny matters. The community showcase format selects for success stories. Sheena's LinkedIn agent is real and presumably functional. But we don't see the builds that stalled, the members who spent an afternoon on a task that Goldie claims takes "an hour or two," or the automations that ran for a week and then silently started producing garbage. That's not a knock on Goldie specifically—it's the structural limitation of the testimonial-forward demo format across the entire AI tools space.

The chief of staff concept is actually the most interesting build in the session, and worth pausing on. An agent that monitors projects, surfaces what matters, and runs on a daily schedule is a genuinely useful automation pattern—one that requires not just a clever prompt but a reasonably well-structured operating manual for your own work. The prompt does the easy part. Knowing what to put in it is the actual labor.

Token Management as the Hidden Cost

About halfway through the session, the conversation shifts from "here's what's possible" to "here's how to keep it from bankrupting you," and this is where Goldie is at his most practically useful.

Token costs are the part of AI automation hype that doesn't show up in the demo. When you're running agents on continuous loops against frontier models, costs compound quickly. Goldie's community has apparently been pressure-testing this, and the session covers a cluster of mitigation strategies: Superpowers (a free open-source project on GitHub that helps reduce token consumption), tools called Headroom and Caveman, and a general orchestration principle—use your most capable model as a brain that delegates subtasks to cheaper models rather than routing everything through the expensive endpoint.

"If it's just a task like create content, you don't need a frontier model for that," Goldie notes. "You can just use an older model and it'll still do a really good job." His framing is model orchestration as cost architecture: the smart model decides, the cheaper model executes.

There's also the Caveman approach, which is exactly what it sounds like—instructing the model to respond more tersely, reducing output token burn. It's the kind of hack that feels embarrassingly low-tech next to the "AI operating system" framing, but it works, and the fact that it's in a practitioner's playbook says something real about the maturity gap between the capability demos and the production economics.

Hermes vs. Everything Else

The Hermes vs. OpenClaw section is the most platform-specific part of the session, and it has the most caveats. Goldie's recommendation is basically: pick Hermes, use it for everything, don't split your attention. "It's so much smoother to use, much easier, much simpler. It tends to do everything first time round."

The practical guidance on model connections is more interesting. You can't pipe a Claude subscription directly through the CLI—you need to use API access or an interface layer. For users watching costs, Goldie points to a cost-effective open-weight coding model as an alternative backend that can be plugged directly into Hermes. The broader principle is that the Agent OS architecture is designed to be model-agnostic at the execution layer, which is sensible—you don't want your automation stack locked to a single provider's pricing decisions.

He also mentions Hermes Apollo, a voice-activated variant that can build in real time and open applications on your computer. This is briefly mentioned rather than demonstrated, but it points toward a category of agent capability—ambient, voice-triggered, operating-system-level—that's developing faster than most people outside these practitioner communities are tracking.

Mobile Access and Infrastructure Hygiene

One of the less-flashy questions in the session—how to access the Agent OS from a phone—surfaces something useful: Tailscale and Cloudflare as the two main VPS-based solutions for remote access. Multiple community members are apparently running their Agent OS on virtual private servers and accessing it from mobile. That's a meaningful infrastructure commitment for people Goldie keeps describing as non-technical.

It's not a contradiction exactly, but it's a tension. The "just describe it and the agent builds it" framing coexists with a setup that, for mobile access alone, involves configuring a VPS and a network tunneling tool. These aren't insurmountable steps, but they're also not nothing.

What the Demo Doesn't Show

The session's real value is as a practitioner artifact—a record of what a working community of AI automation builders actually runs into. Token limits. Model selection. Infrastructure access. The gap between a goal that terminates and a schedule that loops. These are the real problems, and Goldie addresses them with the specificity of someone who has actually hit them.

What the format can't show is the maintenance curve. "I've never really had to touch it since. And it just runs on a loop automatically," Goldie says about one of his core automations. That claim is plausible for a stable, well-scoped task running against reliable APIs. It gets harder to believe when news sources change their structure, when API endpoints deprecate, when models update and prompts that worked last month produce different outputs this month.

The architecture is genuinely interesting. The token management questions are real and the community's solutions are worth knowing. But the "set it and forget it" frame is doing a lot of rhetorical work. The ongoing-maintenance math is harder to close than the setup demo suggests.

Dev Kapoor covers open source software and developer communities for Buzzrag.