Aeon vs Hermes: two autonomous agents, one big difference

Aeon vs the Others, #1. Hermes lives on your machine; Aeon lives in the cloud and heals itself.

Aeon and Hermes are the closest pair in this series. Both open source, both model-agnostic, both built for an agent that acts on its own instead of waiting for prompts. The main difference is infrastructure. Hermes (by Nous Research) is a self-improving assistant that runs on your computer and talks to you in your terminal and chat apps. Aeon runs on GitHub Actions, so there is no host machine and no daemon to keep alive, and scheduling, run scoring, and self-repair are built into the runtime.

Same ambition around the agentic approach, different bet on where an autonomous agent should live.

Set up Aeon. Free, MIT, runs on your own GitHub account.

Aeon is a framework that you can fork, creating your own aeon instance. Skills are plain Markdown files, scheduled on cron or fired by reactive triggers, executed in GitHub's cloud by any of ten harnesses (Claude, Grok, Codex, Pi, Vibe, Kimi, fx, Cursor, Hermes, GLM). A model scores every run 1-5. Broken skills get diagnosed and patched by the skill-health and skill-repair loop. It notifies you on Telegram, Discord, Slack, Buzz, or email, and can spawn specialized copies of itself into a fleet.

Hermes is Nous Research's open-source agent for your own hardware. Model-agnostic, remembers across conversations, improves itself over time, reaches you through terminal and chat apps. It reacts to messages and events: an assistant you talk to, running where you can see it.

• Runtime - Aeon: GitHub Actions, no machine. Hermes: your machine, kept running.
• Stays on when your hardware is off - Aeon: yes. Hermes: no.
• Scheduling - Aeon: cron, native to the runtime. Hermes: chat / event driven.
• Reactive triggers - Aeon: condition-based. Hermes: message triggers.
• Self-healing - Aeon: auto-diagnoses and patches failing skills. Hermes: none.
• Quality scoring - Aeon: every run scored 1-5. Hermes: none.
• Model choice - Aeon: 10 harnesses behind one contract. Hermes: model-agnostic.
• Persistent memory - Aeon: versioned files in the repo (SOUL.md, STRATEGY.md). Hermes: persistent memory.
• Skill format - Aeon: Markdown (SKILL.md). Hermes: skill documents.
• Open source - Both. Aeon is MIT.
• Data locality - Aeon: runs in GitHub's cloud. Hermes: everything on your box.
• Local / private models - Aeon: via harness support. Hermes: natural fit.
• Fleet of specialized instances - Aeon: yes, isolated billing, no shared secrets. Hermes: no.
• Audit trail - Aeon: every run is an Actions log in your repo. Hermes: local logs.
• Hosting cost - Aeon: free on public repos. Hermes: your machine plus power.

Aeon: free, MIT-licensed. Compute is free (public-repo Actions minutes). You bring model auth, a Claude subscription or API keys for whichever harness you pick.

Hermes: free, open source. You bring API keys or run local models, and your hardware is the server.

Both are free software. The cost question is really whose computer: yours (Hermes) or GitHub's (Aeon).

• You want everything (model, memory, execution) on hardware you physically control.
• Your agent is mostly conversational: an assistant you message, that messages back.
• You run local models and want the shortest path to them.
• Keeping a machine on 24/7 is fine. Home server, spare box.

• The work is scheduled and recurring: briefs, monitoring, repo review, research digests, disclosures.
• You don't want to be your agent's sysadmin. No daemon, no uptime, no box to babysit.
• You want the runtime to notice failures and repair them, not just log them.
• You want receipts. Every run is a scored, inspectable Actions log in a repo you own.
• You want to split work across a fleet of specialized instances.

In one line: Hermes is autonomous on your machine, and you keep the host alive. Aeon is autonomous without a host.

Aren't Aeon and Hermes basically the same thing?

They overlap more than any other pair in this series: open source, model-agnostic, persistent memory, real autonomy. The difference is operational. Hermes depends on a machine you keep running. Aeon's runtime is GitHub Actions, and it adds cron scheduling, per-run scoring, and self-repair at the framework level.

Is running in GitHub's cloud a privacy trade-off?

It's a trade. Hermes keeps everything local, which is stronger for sensitive data. What Aeon gets back is auditability: every run, log, and memory change is versioned in a repo you own, and secrets are sealed as Actions secrets instead of sitting in a local config.

Can Aeon use the same models as Hermes?

Aeon executes through ten agent harnesses (Claude, Grok, Codex, Pi, Vibe, Kimi, fx, Cursor, Hermes, GLM) and you swap them in config without touching skills. Hermes is model-agnostic at the API level, including local models, which Aeon's cloud runtime doesn't naturally reach.

What does self-healing actually mean?

A model scores every run 1-5. Low scores and failures trip heartbeat, then skill-health, then skill-repair: the failing skill gets diagnosed, patched, and re-run without you filing anything. Neither Hermes nor anything else in this comparison closes that loop.

Can I run both?

Sure, they don't conflict. A common split: Hermes as the local, private, conversational layer, Aeon as the cloud layer doing scheduled work and reporting into the same chat apps.

• #2 - Aeon vs Claude Code: same engine, nobody at the wheel
• #3 - Aeon vs ChatGPT: the agent that works while you're gone
• #4 - Aeon vs Grok Bot: the $300 agent and the free one

Point any coding agent at https://www.aeon.fun/skills/aeon.md, or fork aeonfun/aeon and run ./aeon.

Configure once, forget forever!