🧭 How to compare AI operating systems + the category map
The “AI operating systems” market has turned into a noisy bazaar: dozens of projects, each promising to be your definitive Jarvis. Before diving into the names (that’s the next module), this one gives you the yardstick: the 5 criteria for judging any system, the 4 map categories, the local vs. cloud axis, and the "less is more" thesis. After this module, you'll compare them based on criteria — not hype.
❓ The question everyone answers
It seems like a new “AI operating system” is born every week. OpenClaw, GravityClaw, Hermes, Intelecto, AIOS, MemGPT, Operator… the list goes on. From the outside, it looks like a mess of unrelated projects. But they have something in common — and that's exactly what makes sense of the map. They all respond to a single question: “how do I run MY AI—agent, memory, and personality—without being held hostage by a closed chatbot from a company?”
When you use ChatGPT or Claude on the website, the memory, rules, and limits belong to the company. You rents intelligence. This course’s family of projects wants the opposite: for YOU to be the owner—for the agent to run wherever you tell it, remember whatever you want, and follow the personality you write. Each system answers this question with different choices; comparing them is precisely how you understand those choices.
🧭 The master question, in one sentence
"How do I run my personal AI (agent + memory + personality) without relying on a closed chatbot?" — every AI OS is a answer to that question. The differences lie in how each one responds.
- •Agent: what takes action (sends messages, reads the calendar, runs tasks), not just responds.
- •Memory: what it remembers about you between conversations.
- •Personality: the tone, values, and rules you write.
New here? “AI OS” (AI operating system) is the nickname for software that organizes a model + memory + tools + channels so your assistant can “live” — just as Windows organizes programs and peripherals. It’s not a real operating system that you install in place of Windows; it’s a layer that turns AI into your assistant. "Closed chatbot" = a service where the company controls everything (memory, rules, data).
Key concepts
Run your own AI without being tied to a closed chatbot.
Layer that brings together model + memory + tools + channels.
With a chatbot, you rent; here, you own it.
Compare = understand each project’s choices.
📏 The 5 criteria
If they all answer the same question, how do you choose? With a measure of 5 criteria. They are the five questions you ask any system before adopting it. Memorize them: we’ll use exactly these five in the next module to judge OpenClaw, GravityClaw, Hermes, and Intelecto side by side.
🔒 Privacy — where does my data go?
Does the brain run on your machine (locally) or on a company’s server (in the cloud)? Can everything you type leave your home, or not? For sensitive data, this is the first filter.
💸 Cost — how much does this hit your wallet?
Fixed or free cost (local) versus per-token charges (cloud). An agent running 24/7 in the cloud can cost from US$ 500 to US$ 5.000 per month; locally, after the hardware, it's ~US$ 0 per use.
🔍 Control / auditability — can I read the code?
Do you understand and know how to review what the system does, or is it a black box with 100 thousand lines that no one reads? Code you can audit is code you can trust.
🛠️ Effort — clone something ready-made or build it brick by brick?
Some systems are ready to download and run; others you build piece by piece, understanding each one. More effort generally buys you more understanding and control.
⚡ Power — how many integrations does it reach?
How many tools, channels, and services does the system connect? More power = more things it can do for you—but, as we’ll see, more power also expands the risk surface.
📊 The trade-off rule of thumb
These five criteria almost never all align. Moving up the power usually takes down the control (more integrations = more code to audit). Maximize privacy (local) often costs effort and it’s power. Comparing means seeing which axis each project chose to sacrifice.
There is no absolute "best"—there's the best for what you values.
New here? "Auditability" is the ability to inspect and understand what a system does internally — read the code, view the logs, check every action. A "token" is a piece of text that cloud models charge for (each word becomes one or more tokens). An "integration" is any external service connected to the agent (Gmail, calendar, GitHub).
Key concepts
Local (doesn't leave your device) vs. cloud (data is transmitted).
Fixed/free vs. per token.
Can you read and trust the code?
Clone vs. build; and how many integrations it reaches.
🗺️ The 4 categories
With the yardstick in hand, you can sort out the mess. All the projects you'll hear about fall into 4 major categories. Knowing a system’s category already tells you a lot before you read a single line about it: what it’s for, what kind of person uses it, and which of the 5 criteria it tends to prioritize.
The first three categories provide context; the fourth (highlighted, with cyan) and where the OpenClaw/GravityClaw/Intelecto/Hermes family lives—you build your Jarvis from standardized parts instead of buying a ready-made box.
a · Research / kernel
AIOS, MemGPT/Letta. They’re the theory—papers and prototypes that ask, “What would a real operating system for AI agents look like?” You rarely use them directly, but their ideas spill over into everything else.
b · Local assistants / voice
Leon, OVOS, Jan, Home Assistant Assist. Ready-made assistants focused on privacy and voice, running in your home. Great if you want something “that already works” without much programming.
c · Dedicated hardware
Rabbit R1, Humane AI Pin. Physical devices just for AI. A lukewarm to poor reception—the market lesson is that the problem is rarely the hardware; it’s the software and the purpose.
d · Agent frameworks ← ours
LangGraph, CrewAI, MCP (the “Model Context Protocol”—an open standard from Anthropic for plugging tools into an agent; you'll see it in detail in the following tracks). These are the building blocks you use to create your own agent. This is where the course family lives—you build your own Jarvis instead of buying a closed box.
Key concepts
The theory that inspires the rest (AIOS, MemGPT).
Ready, private, voice-based (Leon, Jan, Home Assistant).
Device designed only for AI; poor reception (R1, Humane).
The pieces for building your own — where the course lives.
⚖️ Local vs. cloud — the master axis
Of the 5 criteria, one outweighs the others: where the brain runs. "Local" means the model thinks on YOUR machine; "cloud" means it thinks on a company's server (Anthropic, OpenAI). This one choice brings privacy, cost, and control along with it — which is why we call it the master axis.
🏠 LOCAL — privacy and cost
- ✓Data never leaves home.
- ✓~US$ 0 per use after the hardware.
- ✓Works offline without depending on a service.
- ✗Requires decent hardware; may be slower.
- ✗Local models tend to be less powerful.
☁️ CLOUD — power and convenience
- ✓State-of-the-art, more capable models.
- ✓No hardware setup; runs on any device.
- ✓Fast, always up to date.
- ✗Your data is sent to the company.
- ✗Per-token billing; can get expensive with heavy use.
The best systems treat local↔cloud as a slider, not a switch: you choose per message — sends the sensitive task to the local model and the complicated task to the cloud.
💡 Practical tip
When comparing, don't ask "is this system local OR cloud?" Ask "does it let me choose between the two, and how easily?". Systems like Intelecto and GravityClaw let you switch the brain with a configuration file (the .env)—local for everyday use, cloud for tasks that need muscle.
Key concepts
Brain on your machine; private and inexpensive.
Brain on the server; powerful and convenient.
The choice that affects privacy, cost, and control.
Switch between local and cloud on a case-by-case basis.
🪶 Lean vs. framework — "less is more"
The second comparison axis has less to do with where it runs and more with how much code is underneath. On one side, heavyweight frameworks packed with features and tens of thousands of lines. On the other, the philosophy lean ("lean"): do the same work with as little code as possible — code you can wrap your head around.
The extreme example of this philosophy is the Intellect: a whole personal agent in about 3,000 lines of Python, without Docker, without a web dashboard. At the other extreme are projects with more than 100 thousand lines that no one finishes reading. The lean thesis is direct: “code you understand is worth more than code you clone and never read”. Less code isn’t laziness — it’s security and control.
✓ LEAN (lightweight)
- ✓A few thousand lines—you can read it all.
- ✓You understand every piece; you audit what it does.
- ✓Less code = fewer places for a bug or attack to hide.
- ✓Easy to modify and make entirely your own.
✗ HEAVY FRAMEWORK
- ✗Tens of thousands of lines—no one reads them all.
- ✗Black box: you trust without auditing.
- ✗More surface area for bugs and security failures.
- ✗Hard to adapt; you become dependent on its choices.
📊 The order of magnitude
To feel the difference: Intelecto fits in ~3,000 lines; an OpenClaw exceeds 100,000 lines. There are more than 30× difference to solve, deep down, the same central question. The lean approach bets that this excess almost always costs more than it delivers.
Caution: lean doesn't mean "weak." It means "only what's needed, and everything readable."
New here? A "framework" is a ready-made set of code and structures that you build your program on — it saves work, but embeds the decisions of its creator. "Vendor lock-in" means being stuck with a tool or company to the point where leaving is expensive or difficult. Lean code reduces lock-in because you understand and control everything.
Key concepts
Minimal code; everything readable and auditable.
Ready-made structure; embeds decisions made by others.
Understand > clone; smaller risk surface.
Being stuck; lean frees you from that.
📋 How to read the table in the next module
In the next module, you'll see the systems side by side in a comparison table. Now that you have the yardstick (the 5 criteria), the maps (the 4 categories), and the two axes (local↔cloud, lean↔framework), reading that table becomes easy. This section is your reading guide: what to look at in each column and the pitfall to avoid.
| Table column | What she answers |
|---|---|
| Category | Which of the 4 boxes the system falls into (kernel, local, hardware, framework). |
| Local / cloud | Where the brain runs — and whether you can choose. |
| Cost | Fixed/free or per token; how much it costs in real-world use. |
| Lines / auditability | Can you read the code? Lean or a black box? |
| Channel / security | Is there an open port on the internet? MCP only? Is there a whitelist? |
| Power | How many integrations it can reach—and at what risk cost. |
⚠️ The trap to avoid
Don't be swayed by the "power" column. A system with 700 integrations and 250 thousand stars on GitHub seems the winner—but it may be the most dangerous. More power and more code mean a larger attack surface: more doors, more third-party dependencies, and more places where something can go wrong. A big number doesn't mean it's good.
In the next module, you'll see the real case: a huge system with tens of thousands of installations exposed on the internet, and hundreds of malicious extensions. Power without security is a risk.
🧩 Read in 3 steps
- Identify the category — that already tells you what it’s for.
- Check the master axis (local/cloud) and whether you can choose.
- Check auditability + security before being impressed by power.
Key concepts
What to look at in each comparison column.
A big number doesn't mean it's good or safe.
More code and ports = more places to fail.
Category → master axis → auditability/security.
Self-check (optional): when comparing two AI operating systems, what approach does the module recommend?
🎯 Module summary
Next module:
2-2 — The family at home: OpenClaw, GravityClaw, Hermes, and Intelecto