Agent-as-a-Service: A Rhapsody of Agent Autonomy Starting from Aeon

The following content is a technical analysis and does not constitute investment advice.

In case you don’t know what @aeonframework is: Aeon is an Agent-driven task automation program developed by @aaronjmars (a dev without a long list of titles). By cloning a repo, deploying it on GitHub Actions, and connecting a subscription, you can have the Agent continuously execute tasks according to your initial setup — running 24/7 without downtime.

If you know me, you’ll know I strongly dislike OpenClaw and predicted it would fizzle out soon after it appeared. I’m not saying this to brag, but because I have my own vision for Agent development: Agents should not permanently rely on a handful of tech-savvy end users tinkering on their own. Instead, like in the SaaS era, a small number of skilled developers should be able to open up their specialized Agents to directly solve problems for other users.

I won’t lie and say Aeon represents cutting-edge tech — there’s been some FUD questioning its value recently. My personal take:

(1) In reality, there’s no real innovation left in software engineering in the AI era, and no technology that can’t be cracked. The only thing that might impress another dev is your status and fame.

(2) Something that doesn’t look particularly novel but works smoothly is incredibly rare — and that’s where Hermes beats OpenClaw.

(3) The approach is actually quite clever. Using GitHub Actions is a smart choice that solves online deployment, cost, and transparency (autonomy) issues.

But Aeon is just the first step in a much bigger story.

How to Define AaaS?

As mentioned, AaaS (Agent-as-a-Service) is a philosophy: Agents should take end-to-end responsibility for delivering results, just like traditional SaaS services — not just serve as a small piece of the problem-solving puzzle. While not many people use this term, the practice is already common: for example, you can use Claude for design, Gemini for web pages, Kimi for PPTs, and so on.

But that’s not quite the ideal of true AaaS, or rather, it’s why AaaS differs from SaaS: In SaaS, being human-centric, solving needs, and delivering results is enough. But if AaaS stays at that level, it’s just a technical variation of SaaS — swapping some procedural modules for Agents. That doesn’t change its essence. In my view, AaaS must have these characteristics:

(1) It should not be born to solve “a specific need,” but must have the ability to address “a category of needs.”

(2) Its iteration and maintenance should rely minimally on human devs — instead, it should adapt to changing needs through self-evolution.

(3) Its operation must not depend on human interaction; it needs a complete autonomy logic.

Of course, any legitimate industry will have security, privacy, compliance, etc., but that’s obvious, so I’ll skip it.

What Does Aeon Have to Do with AaaS?

Autonomy (and 24/7 uptime) is the most basic requirement of AaaS. Yet few products currently address this with practical, eye-catching solutions. This is a key judgment I’ve made about Agent development: The demand for autonomy is already more urgent than for harness (because current harness technology and methodology are already decent). You can’t expect users to always run their Codex or OpenClaw locally for various automation needs — office work, information gathering, operations, real-time issue resolution, etc.

Aeon’s first step is to offer a modest but practical solution for autonomy — something I could definitely use in my next product.

This solution has its flaws: being based on a GitHub repo creates a clear barrier for non-technical users, and it can’t meet on-premise deployment needs.

But its strengths are even more obvious: It provides a one-click template for technical users to quickly deploy, and it can potentially be transformed into a complete service. Plus, being backed by GitHub gives Agent operations immense security (ironically, GitHub was recently breached, but even so, I’d trust GitHub Actions far more than an OpenClaw deployed on a VPS).

The Next Step for AaaS

Interestingly, I can almost see all the building blocks on the path to AaaS — just stitching them together might get us there: There’s a wealth of resources for harness and skills. Autonomy can rely on Aeon. Self-evolution can rely on Evomap. Problem-solving can rely on more powerful base models and tool calls. So, problem solved? No.

The real problem is that we’re not ready.

This is an entirely different dimension and evaluation standard for Agents. Whether an Agent is valuable no longer depends on a single impressive answer or whether it can solve a problem once. It depends on whether it can last long-term, work stably, be constrained, self-recover after errors, and earn user trust as a service.

So I’m happy to see the Aeon ecosystem take off. This is certainly not the endgame — it’s a beginning. An open exam for Agent Autonomy: Can they truly be trusted? Can they deliver reliably and correctly?